@reliverse/relinka 1.0.0

package/output/components/mono.js

@@ -0,0 +1,64 @@
+import { confirmPrompt } from "../components/confirm";
+import { datePrompt } from "../components/date";
+import { endPrompt } from "../components/end";
+import { nextStepsPrompt } from "../components/next-steps";
+import { numberPrompt } from "../components/number";
+import { passwordPrompt } from "../components/password";
+import { startPrompt } from "../components/start";
+import { textPrompt } from "../components/text";
+import { numSelectPrompt } from "./num-select.js";
+export async function prompt(options) {
+  const { type, id, action } = options;
+  let value;
+  switch (type) {
+    case "start":
+      await startPrompt(options);
+      value = null;
+      break;
+    case "text":
+      value = await textPrompt(options);
+      break;
+    case "number":
+      value = await numberPrompt(options);
+      break;
+    case "confirm":
+      value = await confirmPrompt(options);
+      break;
+    case "numSelect":
+      value = await numSelectPrompt(options);
+      break;
+    // case "select":
+    //   value = await selectPrompt(options);
+    //   break;
+    // case "multiSelect":
+    //   value = await multiSelectPrompt(options);
+    //   break;
+    // case "numMultiSelect":
+    //   value = await numMultiSelectPrompt(options);
+    //   break;
+    case "password":
+      value = await passwordPrompt(options);
+      break;
+    case "date":
+      value = await datePrompt({
+        ...options,
+        dateFormat: "DD/MM/YYYY",
+        dateKind: "other"
+      });
+      break;
+    case "nextSteps":
+      await nextStepsPrompt(options);
+      value = null;
+      break;
+    case "end":
+      await endPrompt(options);
+      value = null;
+      break;
+    default:
+      throw new Error(`Unknown prompt type: ${type}`);
+  }
+  if (action) {
+    await action();
+  }
+  return { [id]: value };
+}

package/output/components/next-steps.d.ts

@@ -0,0 +1,2 @@
+import type { PromptOptions } from "../types/prod";
+export declare function nextStepsPrompt(options: PromptOptions): Promise<void>;

package/output/components/next-steps.js

@@ -0,0 +1,25 @@
+import { msg } from "../utils/messages";
+export async function nextStepsPrompt(options) {
+  const {
+    title,
+    titleColor = "cyanBright",
+    answerColor = "none",
+    titleVariant,
+    titleTypography = "bold",
+    content,
+    contentColor,
+    contentVariant,
+    contentTypography
+  } = options;
+  msg({
+    type: "M_INFO",
+    title,
+    titleColor,
+    titleVariant,
+    titleTypography,
+    content,
+    contentColor,
+    contentVariant,
+    contentTypography
+  });
+}

package/output/components/num-multi-select.d.ts

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

package/output/components/num-multi-select.js

@@ -0,0 +1,108 @@
+import { Value } from "@sinclair/typebox/value";
+import { stdin as input, stdout as output } from "node:process";
+import readline from "node:readline/promises";
+import { colorize } from "../utils/colorize";
+import { bar, fmt, msg } from "../utils/messages";
+import { countLines, deleteLastLine, deleteLastLines } from "../utils/terminal";
+export async function numMultiSelectPrompt(options) {
+  const {
+    title,
+    choices,
+    schema,
+    defaultValue,
+    titleColor = "cyanBright",
+    answerColor = "none",
+    titleTypography = "bold",
+    titleVariant,
+    hint,
+    content,
+    contentColor = "dim",
+    contentTypography,
+    contentVariant,
+    borderColor = "viceGradient",
+    variantOptions
+  } = options;
+  if (!choices || choices.length === 0) {
+    throw new Error("Choices are required for multiselect prompt.");
+  }
+  const rl = readline.createInterface({ input, output });
+  const formattedBar = bar({ borderColor });
+  let linesToDelete = 0;
+  let errorMessage = "";
+  try {
+    while (true) {
+      if (linesToDelete > 0) {
+        deleteLastLines(linesToDelete);
+      }
+      const question = fmt({
+        type: errorMessage !== "" ? "M_ERROR" : "M_GENERAL",
+        title: `${title}${defaultValue ? ` [Default: ${Array.isArray(defaultValue) ? defaultValue.join(", ") : defaultValue}]` : ""}`,
+        titleColor,
+        titleTypography,
+        titleVariant,
+        content,
+        contentColor,
+        contentTypography,
+        contentVariant,
+        borderColor,
+        hint,
+        variantOptions,
+        errorMessage,
+        addNewLineBefore: false,
+        addNewLineAfter: false
+      });
+      const choicesText = choices.map(
+        (choice, index) => `${formattedBar}  ${index + 1}) ${choice.title}${choice.description ? ` - ${choice.description}` : ""}`
+      ).join("\n");
+      const fullPrompt = `${question}
+${choicesText}
+${formattedBar}  ${colorize(`Enter your choices (comma-separated numbers between 1-${choices.length})`, contentColor)}:
+${formattedBar}  `;
+      const formattedPrompt = fmt({
+        type: "M_NULL",
+        title: fullPrompt
+      });
+      const questionLines = countLines(formattedPrompt);
+      linesToDelete = questionLines + 1;
+      const answer = (await rl.question(formattedPrompt)).trim();
+      if (!answer && defaultValue !== void 0) {
+        deleteLastLine();
+        msg({
+          type: "M_MIDDLE",
+          title: `  ${Array.isArray(defaultValue) ? defaultValue.join(", ") : defaultValue}`,
+          titleColor: answerColor
+        });
+        msg({ type: "M_NEWLINE" });
+        return defaultValue;
+      }
+      const selections = answer.split(",").map((s) => s.trim());
+      const invalidSelections = selections.filter((s) => {
+        const num = Number(s);
+        return isNaN(num) || num < 1 || num > choices.length;
+      });
+      if (invalidSelections.length > 0) {
+        errorMessage = `Invalid selections: ${invalidSelections.join(
+          ", "
+        )}. Please enter numbers between 1 and ${choices.length}.`;
+        continue;
+      }
+      const selectedValues = selections.map((s) => choices[Number(s) - 1]?.id);
+      let isValid = true;
+      errorMessage = "";
+      if (schema) {
+        isValid = Value.Check(schema, selectedValues);
+        if (!isValid) {
+          const errors = [...Value.Errors(schema, selectedValues)];
+          errorMessage = errors.length > 0 ? errors[0]?.message ?? "Invalid input." : "Invalid input.";
+        }
+      }
+      if (isValid) {
+        msg({ type: "M_NEWLINE" });
+        rl.close();
+        return selectedValues;
+      }
+    }
+  } finally {
+    rl.close();
+  }
+}

package/output/components/num-select.d.ts

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

package/output/components/num-select.js

@@ -0,0 +1,122 @@
+import { Value } from "@sinclair/typebox/value";
+import { stdin as input, stdout as output } from "node:process";
+import readline from "node:readline/promises";
+import { colorize } from "../utils/colorize";
+import { fmt, msg, bar } from "../utils/messages";
+import { countLines, deleteLastLine, deleteLastLines } from "../utils/terminal";
+export async function numSelectPrompt(options) {
+  const {
+    title,
+    hint,
+    validate,
+    defaultValue,
+    schema,
+    titleColor = "cyanBright",
+    answerColor = "none",
+    titleTypography = "bold",
+    titleVariant,
+    content,
+    contentColor,
+    contentTypography,
+    contentVariant,
+    borderColor = "viceGradient",
+    variantOptions,
+    inline = true,
+    choices
+  } = options;
+  if (!choices || choices.length === 0) {
+    throw new Error("Choices are required for select prompt.");
+  }
+  const rl = readline.createInterface({ input, output });
+  const formattedBar = bar({ borderColor });
+  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
+    });
+    let choicesText = "";
+    if (inline) {
+      choicesText = choices.map(
+        (choice, index) => `${index + 1}) ${choice.title}${choice.description ? ` (${choice.description})` : ""}`
+      ).join(" / ");
+    } else {
+      choicesText = choices.map(
+        (choice, index) => `${index + 1}) ${choice.title}${choice.description ? ` - ${choice.description}` : ""}`
+      ).join(`
+${formattedBar} `);
+    }
+    const formattedPrompt = fmt({
+      type: "M_NULL",
+      title: `${question}${choicesText}
+${formattedBar}  ${colorize(
+        `Enter your choice:`,
+        contentColor
+      )}
+${formattedBar}  `
+    });
+    const questionLines = countLines(formattedPrompt);
+    linesToDelete = questionLines + 1;
+    const prompt = await rl.question(formattedPrompt);
+    const answer = prompt.trim() || defaultValue;
+    if (!prompt.trim() && defaultValue !== void 0) {
+      deleteLastLine();
+      msg({
+        type: "M_MIDDLE",
+        title: `  ${defaultValue}`,
+        titleColor: answerColor
+      });
+    }
+    const num = Number(answer);
+    if (isNaN(num) || num < 1 || num > choices.length) {
+      errorMessage = `Please enter a number between 1 and ${choices.length}.`;
+      continue;
+    }
+    const selectedChoice = choices[num - 1];
+    const selectedValue = selectedChoice?.id ?? num;
+    let isValid = true;
+    errorMessage = "";
+    if (schema) {
+      isValid = Value.Check(schema, selectedValue);
+      if (!isValid) {
+        const errors = [...Value.Errors(schema, selectedValue)];
+        if (errors.length > 0) {
+          errorMessage = errors[0]?.message ?? "Invalid input.";
+        } else {
+          errorMessage = "Invalid input.";
+        }
+      }
+    }
+    if (validate && isValid) {
+      const validation = await validate(selectedValue);
+      if (validation !== true) {
+        isValid = false;
+        errorMessage = typeof validation === "string" ? validation : "Invalid input.";
+      }
+    }
+    if (isValid) {
+      msg({ type: "M_NEWLINE" });
+      rl.close();
+      if (selectedChoice?.action) {
+        await selectedChoice.action();
+      }
+      return selectedValue;
+    } else {
+    }
+  }
+}

package/output/components/number.d.ts

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

package/output/components/number.js

@@ -0,0 +1,92 @@
+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 numberPrompt(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 !== void 0) {
+      deleteLastLine();
+      const defaultMsg = fmt({
+        type: "M_MIDDLE",
+        title: `  ${defaultValue}`,
+        borderColor
+      });
+      console.log(defaultMsg);
+      linesToDelete += countLines(defaultMsg);
+    }
+    const num = Number(answer);
+    if (isNaN(num)) {
+      errorMessage = "Please enter a valid number.";
+      continue;
+    }
+    let isValid = true;
+    errorMessage = "";
+    if (schema) {
+      isValid = Value.Check(schema, num);
+      if (!isValid) {
+        const errors = [...Value.Errors(schema, num)];
+        if (errors.length > 0) {
+          errorMessage = errors[0]?.message ?? "Invalid input.";
+        } else {
+          errorMessage = "Invalid input.";
+        }
+      }
+    }
+    if (validate && isValid) {
+      const validation = await validate(num);
+      if (validation !== true) {
+        isValid = false;
+        errorMessage = typeof validation === "string" ? validation : "Invalid input.";
+      }
+    }
+    if (isValid) {
+      msg({ type: "M_NEWLINE" });
+      rl.close();
+      return num;
+    } else {
+    }
+  }
+}

package/output/components/password.d.ts

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

package/output/components/password.js

@@ -0,0 +1,117 @@
+import { Value } from "@sinclair/typebox/value";
+import { bar, fmt } from "../utils/messages";
+import { countLines, deleteLastLines } from "../utils/terminal";
+export async function passwordPrompt(options) {
+  const {
+    title,
+    hint,
+    validate,
+    schema,
+    defaultValue,
+    titleColor = "cyanBright",
+    answerColor = "none",
+    titleTypography = "bold",
+    titleVariant,
+    content,
+    contentColor,
+    contentTypography,
+    contentVariant,
+    borderColor = "viceGradient",
+    variantOptions
+  } = options;
+  let linesToDelete = 0;
+  let errorMessage = "";
+  while (true) {
+    const question = fmt({
+      type: errorMessage !== "" ? "M_ERROR" : "M_GENERAL",
+      title: `${title}${defaultValue ? ` [Default: ****]` : ""}`,
+      titleColor,
+      titleTypography,
+      titleVariant,
+      content,
+      contentColor,
+      contentTypography,
+      contentVariant,
+      borderColor,
+      hint,
+      variantOptions,
+      errorMessage
+    });
+    const questionLines = countLines(question);
+    if (linesToDelete > 0) {
+      deleteLastLines(linesToDelete);
+    }
+    process.stdout.write(question);
+    const password = await readPassword(borderColor);
+    linesToDelete = questionLines + 1;
+    const formattedBar = bar({ borderColor });
+    if (!password.trim() && defaultValue !== void 0) {
+      deleteLastLines(2);
+      process.stdout.write(`${formattedBar}  ****`);
+      console.log(`
+${formattedBar}`);
+      return defaultValue;
+    }
+    let isValid = true;
+    errorMessage = "";
+    if (schema) {
+      isValid = Value.Check(schema, password);
+      if (!isValid) {
+        const errors = [...Value.Errors(schema, password)];
+        if (errors.length > 0) {
+          errorMessage = errors[0]?.message ?? "Invalid input.";
+        } else {
+          errorMessage = "Invalid input.";
+        }
+      }
+    }
+    if (validate && isValid) {
+      const validation = await validate(password);
+      if (validation !== true) {
+        isValid = false;
+        errorMessage = typeof validation === "string" ? validation : "Invalid input.";
+      }
+    }
+    if (isValid) {
+      process.stdout.write("\n");
+      return password;
+    } else {
+    }
+  }
+}
+function readPassword(borderColor) {
+  return new Promise((resolve, reject) => {
+    const stdin = process.stdin;
+    let password = "";
+    const formattedBar = bar({ borderColor });
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    const onData = function(char) {
+      char = char.toString();
+      if (char === "\n" || char === "\r" || char === "") {
+        stdin.setRawMode(false);
+        stdin.pause();
+        stdin.removeListener("data", onData);
+        process.stdout.write(`
+${formattedBar}`);
+        resolve(password.trim());
+      } else if (char === "") {
+        stdin.setRawMode(false);
+        stdin.pause();
+        stdin.removeListener("data", onData);
+        reject(new Error("User aborted."));
+      } else if (char === "\x7F" || // Backspace
+      char === "\b" || char === "\x7F" || char === "\b") {
+        if (password.length > 0) {
+          password = password.slice(0, -1);
+          process.stdout.write("\b \b");
+        }
+      } else {
+        password += char;
+        process.stdout.write("*");
+      }
+    };
+    stdin.on("data", onData);
+  });
+}

package/output/components/results.d.ts

@@ -0,0 +1,10 @@
+import type { Static } from "@sinclair/typebox";
+declare const ResultsSchema: import("@sinclair/typebox").TObject<{
+    username: import("@sinclair/typebox").TString;
+}>;
+type ResultsType = Static<typeof ResultsSchema>;
+export declare function promptsDisplayResults({ results, inline, }: {
+    results: ResultsType;
+    inline?: boolean;
+}): Promise<void>;
+export {};

package/output/components/results.js

@@ -0,0 +1,34 @@
+import { Type } from "@sinclair/typebox";
+import { Value } from "@sinclair/typebox/value";
+import { msg } from "../utils/messages";
+const ResultsSchema = Type.Object({
+  username: Type.String()
+});
+export async function promptsDisplayResults({
+  results,
+  inline = true
+}) {
+  if (!Value.Check(ResultsSchema, results)) {
+    throw new Error("Invalid results structure.");
+  }
+  const title = "Your input results:";
+  if (inline) {
+    const formattedResults = Object.entries(results).map(([key, value]) => `${key}: ${value}`).join(", ");
+    msg({
+      type: "M_INFO",
+      title,
+      content: formattedResults,
+      titleColor: "cyan",
+      contentColor: "dim"
+    });
+  } else {
+    const formattedResults = JSON.stringify(results, null, 2);
+    msg({
+      type: "M_INFO",
+      title,
+      content: formattedResults,
+      titleColor: "cyan",
+      contentColor: "dim"
+    });
+  }
+}

package/output/components/select.d.ts

@@ -0,0 +1,2 @@
+import type { PromptOptions } from "../types/prod";
+export declare function selectPrompt(options: PromptOptions): Promise<string>;