@reliverse/rempts-core 1.6.1

package/bin/core-impl/number/number-mod.js

@@ -0,0 +1,197 @@
+import { stdin as input, stdout as output } from "node:process";
+import readline from "node:readline/promises";
+import { bar, msg } from "../msg-fmt/messages.js";
+import {
+  deleteLastLine,
+  deleteLastLines
+} from "../msg-fmt/terminal.js";
+function renderPromptUI(params) {
+  const {
+    title,
+    hint,
+    content,
+    contentColor = "dim",
+    contentTypography = "italic",
+    contentVariant,
+    titleColor = "cyan",
+    titleTypography = "none",
+    titleVariant,
+    borderColor = "dim",
+    userInput,
+    errorMessage
+  } = params;
+  let lineCount = 0;
+  const type = errorMessage !== "" ? "M_ERROR" : "M_GENERAL";
+  const msgParams = {
+    type,
+    title,
+    titleColor,
+    titleTypography,
+    titleVariant: titleVariant ?? "none",
+    content: content ?? "",
+    contentColor,
+    contentTypography,
+    contentVariant: contentVariant ?? "none",
+    borderColor,
+    hint: hint ?? "",
+    errorMessage
+  };
+  msg(msgParams);
+  lineCount++;
+  if (userInput !== "") {
+    msg({ type: "M_MIDDLE", title: `  ${userInput}` });
+    lineCount++;
+  }
+  return lineCount;
+}
+export async function numberPrompt(opts) {
+  const {
+    title = "",
+    hint,
+    hintPlaceholderColor = "blue",
+    validate,
+    defaultValue,
+    titleColor = "cyan",
+    titleTypography = "none",
+    titleVariant,
+    content,
+    contentColor = "dim",
+    contentTypography = "italic",
+    contentVariant,
+    borderColor = "dim",
+    hardcoded,
+    endTitle = "",
+    endTitleColor = "dim",
+    border = true
+  } = opts;
+  const rl = readline.createInterface({ input, output });
+  rl.on("SIGINT", () => {
+    if (endTitle !== "") {
+      msg({
+        type: "M_END",
+        title: endTitle,
+        titleColor: endTitleColor,
+        titleTypography,
+        border,
+        borderColor
+      });
+    }
+    rl.close();
+    process.exit(0);
+  });
+  let currentInput = hardcoded?.userInput || "";
+  let errorMessage = hardcoded?.errorMessage || "";
+  let isRerender = false;
+  let lastLineCount = 0;
+  const effectiveDefault = typeof defaultValue === "string" ? Number(defaultValue) : defaultValue;
+  if (hardcoded?.userInput !== void 0) {
+    renderPromptUI({
+      title,
+      hint,
+      hintPlaceholderColor,
+      content,
+      contentColor,
+      contentTypography,
+      contentVariant,
+      titleColor,
+      titleTypography,
+      titleVariant,
+      borderColor,
+      userInput: currentInput,
+      errorMessage,
+      border,
+      isRerender
+    });
+    const num = Number(currentInput);
+    if (Number.isNaN(num)) {
+      throw new Error("Please enter a valid number.");
+    }
+    const validated = await validateInput(num, validate);
+    if (validated.isValid) {
+      msg({ type: "M_MIDDLE", title: `  ${num}` });
+      msg({ type: "M_BAR", borderColor });
+      rl.close();
+      return num;
+    }
+    rl.close();
+    throw new Error(validated.errorMessage || "Invalid input.");
+  }
+  while (true) {
+    if (isRerender) {
+      deleteLastLines(lastLineCount + 1);
+    }
+    lastLineCount = renderPromptUI({
+      title,
+      hint,
+      hintPlaceholderColor,
+      content,
+      contentColor,
+      contentTypography,
+      contentVariant,
+      titleColor,
+      titleTypography,
+      titleVariant,
+      borderColor,
+      userInput: currentInput,
+      errorMessage,
+      border,
+      isRerender
+    });
+    const formattedBar = bar({ borderColor });
+    const answerInput = await rl.question(`${formattedBar}  `);
+    isRerender = true;
+    if (answerInput === null) {
+      if (endTitle !== "") {
+        msg({
+          type: "M_END",
+          title: endTitle,
+          titleColor: endTitleColor,
+          titleTypography,
+          border,
+          borderColor
+        });
+      }
+      rl.close();
+      process.exit(0);
+    }
+    currentInput = answerInput.trim();
+    if (!currentInput && effectiveDefault !== void 0) {
+      deleteLastLine();
+      msg({ type: "M_MIDDLE", title: `  ${effectiveDefault}` });
+      msg({ type: "M_BAR", borderColor });
+      rl.close();
+      return effectiveDefault;
+    }
+    const num = Number(currentInput);
+    if (Number.isNaN(num)) {
+      errorMessage = "Please enter a valid number.";
+      continue;
+    }
+    const validated = await validateInput(num, validate);
+    if (validated.isValid) {
+      deleteLastLine();
+      msg({ type: "M_MIDDLE", title: `  ${num}` });
+      msg({ type: "M_BAR", borderColor });
+      rl.close();
+      return num;
+    }
+    errorMessage = validated.errorMessage;
+  }
+}
+async function validateInput(input2, validate) {
+  let isValid = true;
+  let errorMessage = "";
+  if (validate && isValid) {
+    const validationResult = await validate(input2);
+    if (validationResult === true || validationResult === void 0) {
+      isValid = true;
+    } else if (typeof validationResult === "string") {
+      isValid = false;
+      errorMessage = validationResult;
+    } else {
+      isValid = false;
+      errorMessage = "Invalid input.";
+    }
+  }
+  return { isValid, errorMessage };
+}

package/bin/core-impl/results/results.d.ts

@@ -0,0 +1,7 @@
+export type ResultsType = {
+    username: string;
+};
+export declare function resultPrompt({ results, inline, }: {
+    results: ResultsType;
+    inline?: boolean;
+}): Promise<void>;

package/bin/core-impl/results/results.js

@@ -0,0 +1,27 @@
+import { msg } from "../msg-fmt/messages.js";
+export async function resultPrompt({
+  results,
+  inline = true
+}) {
+  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",
+      wrapContent: true
+    });
+  } else {
+    const formattedResults = JSON.stringify(results, null, 2);
+    msg({
+      type: "M_INFO",
+      title,
+      content: formattedResults,
+      titleColor: "cyan",
+      contentColor: "dim"
+    });
+  }
+}

package/bin/core-impl/select/multiselect-prompt.d.ts

@@ -0,0 +1,2 @@
+import type { MultiselectPromptParams } from "../../core-types.js";
+export declare function multiselectPrompt<T extends string>(params: MultiselectPromptParams<T>): Promise<T[]>;

package/bin/core-impl/select/multiselect-prompt.js

@@ -0,0 +1,341 @@
+import { re } from "@reliverse/relico";
+import { stdin as input, stdout as output } from "node:process";
+import readline from "node:readline";
+import { msg, symbols } from "../msg-fmt/messages.js";
+import { deleteLastLine } from "../msg-fmt/terminal.js";
+import { completePrompt } from "../utils/prompt-end.js";
+function isSelectOption(option) {
+  return !("separator" in option);
+}
+function renderPromptUI(params) {
+  const {
+    title,
+    content,
+    options,
+    pointer,
+    selectedOptions,
+    errorMessage,
+    displayInstructions,
+    instructions,
+    allDisabled,
+    titleColor,
+    contentColor,
+    contentTypography,
+    debug,
+    titleVariant,
+    titleTypography,
+    isRerender = false
+  } = params;
+  if (!isRerender) {
+    msg({
+      type: "M_NULL",
+      title,
+      titleColor,
+      ...titleTypography ? { titleTypography } : {},
+      ...titleVariant ? { titleVariant } : {}
+    });
+    if (content) {
+      msg({
+        type: "M_NULL",
+        content,
+        contentColor,
+        contentTypography
+      });
+    }
+  }
+  let uiLineCount = 0;
+  if (errorMessage) {
+    msg({
+      type: "M_NULL",
+      title: `${re.redBright(symbols.step_error)} ${re.redBright(errorMessage)}`
+    });
+    uiLineCount++;
+  } else if (allDisabled) {
+    msg({ type: "M_NULL", title: re.redBright("All options are disabled.") });
+    uiLineCount++;
+  } else if (displayInstructions && !isRerender) {
+    msg({ type: "M_NULL", title: re.blue(instructions) });
+    uiLineCount++;
+  }
+  for (let index = 0; index < options.length; index++) {
+    const option = options[index];
+    if (!option) continue;
+    if (!isSelectOption(option)) {
+      const width = option.width ?? 20;
+      const symbolKey = option.symbol ?? "line";
+      const lineSymbol = symbolKey in symbols ? symbols[symbolKey] : "\u2500";
+      msg({ type: "M_NULL", title: re.dim(lineSymbol.repeat(width)) });
+      uiLineCount++;
+      continue;
+    }
+    const isSelected = selectedOptions.has(index);
+    const isHighlighted = index === pointer;
+    const isDisabled = option.disabled;
+    const checkbox = isSelected ? "[x]" : "[ ]";
+    const prefix = isHighlighted ? re.yellow(re.reset("> ")) : "  ";
+    const labelColor = isDisabled ? re.dim(re.reset(option.label)) : isHighlighted ? re.reset(re.yellow(option.label)) : re.reset(option.label);
+    const hint = option.hint ? re.reset(
+      ` (${isDisabled ? re.dim(option.hint) : re.gray(option.hint)})`
+    ) : "";
+    const formattedCheckbox = isHighlighted ? re.yellow(checkbox) : checkbox;
+    msg({
+      type: "M_NULL",
+      title: `${prefix}${formattedCheckbox} ${labelColor}${hint}`
+    });
+    uiLineCount++;
+  }
+  if (debug) {
+    console.log({ optionsCount: options.length });
+  }
+  return uiLineCount;
+}
+export async function multiselectPrompt(params) {
+  const {
+    title = "",
+    content = "",
+    options,
+    defaultValue = [],
+    borderColor = "dim",
+    titleColor = "cyan",
+    titleTypography = "none",
+    titleVariant,
+    contentColor = "dim",
+    contentTypography = "italic",
+    border = true,
+    endTitle = "",
+    endTitleColor = "dim",
+    debug = false,
+    terminalWidth: customTerminalWidth = 90,
+    displayInstructions = false,
+    minSelect = 0,
+    maxSelect,
+    selectAll = false
+  } = params;
+  let pointer = defaultValue.length > 0 ? options.findIndex(
+    (opt) => opt && isSelectOption(opt) && defaultValue.includes(opt.value) && !opt.disabled
+  ) : 0;
+  if (pointer === -1) {
+    pointer = options.findIndex(
+      (opt) => opt && isSelectOption(opt) && !opt.disabled
+    );
+    if (pointer === -1) {
+      pointer = 0;
+    }
+  }
+  const selectedOptions = new Set(
+    selectAll ? options.map(
+      (opt, index) => opt && isSelectOption(opt) && !opt.disabled ? index : -1
+    ).filter((i) => i !== -1) : defaultValue.map(
+      (val) => options.findIndex((o) => o && isSelectOption(o) && o.value === val)
+    ).filter(
+      (i) => i >= 0 && options[i] && isSelectOption(options[i]) && !options[i].disabled
+    )
+  );
+  const rl = readline.createInterface({ input, output });
+  readline.emitKeypressEvents(input, rl);
+  if (typeof input.setRawMode === "function") {
+    input.setRawMode(true);
+  }
+  let errorMessage = "";
+  const allDisabled = options.filter(isSelectOption).every((option) => option.disabled);
+  const instructions = "Use <\u2191/\u2193> to navigate, <Space> to toggle, <A> to toggle all";
+  function toggleSelectAll() {
+    const selectableIndexes = options.map((opt, i) => isSelectOption(opt) && !opt.disabled ? i : -1).filter((i) => i !== -1);
+    const allSelected = selectableIndexes.every((i) => selectedOptions.has(i));
+    if (allSelected) {
+      for (const i of selectableIndexes) {
+        selectedOptions.delete(i);
+      }
+    } else {
+      for (const i of selectableIndexes) {
+        selectedOptions.add(i);
+      }
+    }
+  }
+  function movePointerUp() {
+    const originalPointer = pointer;
+    do {
+      pointer = (pointer - 1 + options.length) % options.length;
+      const currentOption = options[pointer];
+      if (currentOption && isSelectOption(currentOption) && !currentOption.disabled) {
+        break;
+      }
+    } while (pointer !== originalPointer);
+    errorMessage = "";
+  }
+  function movePointerDown() {
+    const originalPointer = pointer;
+    do {
+      pointer = (pointer + 1) % options.length;
+      const currentOption = options[pointer];
+      if (currentOption && isSelectOption(currentOption) && !currentOption.disabled) {
+        break;
+      }
+    } while (pointer !== originalPointer);
+    errorMessage = "";
+  }
+  let lastUILineCount = 0;
+  function renderOptions() {
+    if (lastUILineCount > 0) {
+      for (let i = 0; i < lastUILineCount; i++) {
+        process.stdout.write("\x1B[1A\x1B[2K");
+      }
+    }
+    lastUILineCount = renderPromptUI({
+      title,
+      content,
+      options,
+      pointer,
+      selectedOptions,
+      errorMessage,
+      displayInstructions,
+      instructions,
+      allDisabled,
+      titleColor,
+      contentColor,
+      contentTypography,
+      debug,
+      borderColor,
+      titleVariant,
+      titleTypography,
+      terminalWidth: customTerminalWidth,
+      resized: false,
+      isRerender: true
+    });
+  }
+  lastUILineCount = renderPromptUI({
+    title,
+    content,
+    options,
+    pointer,
+    selectedOptions,
+    errorMessage,
+    displayInstructions,
+    instructions,
+    allDisabled,
+    titleColor,
+    contentColor,
+    contentTypography,
+    debug,
+    borderColor,
+    titleVariant,
+    titleTypography,
+    terminalWidth: customTerminalWidth,
+    resized: false,
+    isRerender: false
+  });
+  return new Promise((resolve) => {
+    function cleanup(isCtrlC = false) {
+      if (typeof input.setRawMode === "function") {
+        input.setRawMode(false);
+      }
+      rl.close();
+      input.removeListener("keypress", handleKeypress);
+      if (isCtrlC) {
+        process.exit(0);
+      }
+    }
+    async function endPrompt(isCtrlC = false) {
+      await completePrompt(
+        "multiselect",
+        isCtrlC,
+        endTitle,
+        endTitleColor,
+        titleTypography,
+        titleVariant ? titleVariant : void 0,
+        border,
+        borderColor,
+        void 0,
+        false
+      );
+      cleanup(isCtrlC);
+    }
+    async function confirmSelection() {
+      const selectedCount = selectedOptions.size;
+      if (selectedCount < minSelect) {
+        deleteLastLine();
+        errorMessage = `You must select at least ${minSelect} option${minSelect !== 1 ? "s" : ""}.`;
+        renderOptions();
+        return;
+      }
+      if (maxSelect !== void 0 && selectedCount > maxSelect) {
+        deleteLastLine();
+        errorMessage = `You can select at most ${maxSelect} option${maxSelect !== 1 ? "s" : ""}.`;
+        renderOptions();
+        return;
+      }
+      const selectedValues = Array.from(selectedOptions).filter((idx) => {
+        const opt = options[idx];
+        return opt && isSelectOption(opt) && !opt.disabled;
+      }).map((idx) => {
+        const opt = options[idx];
+        return opt && isSelectOption(opt) ? opt.value : null;
+      }).filter((val) => val !== null && val !== void 0);
+      cleanup();
+      resolve(selectedValues);
+      deleteLastLine();
+      await completePrompt(
+        "multiselect",
+        false,
+        endTitle,
+        endTitleColor,
+        titleTypography,
+        titleVariant ? titleVariant : void 0,
+        border,
+        borderColor,
+        void 0,
+        true
+      );
+    }
+    function handleKeypress(_str, key) {
+      if (allDisabled) {
+        if (key.name === "c" && key.ctrl) {
+          void endPrompt(true);
+          return;
+        }
+        return;
+      }
+      switch (key.name) {
+        case "up":
+        case "k":
+          movePointerUp();
+          renderOptions();
+          break;
+        case "down":
+        case "j":
+          movePointerDown();
+          renderOptions();
+          break;
+        case "space": {
+          const currentOption = options[pointer];
+          if (!currentOption || !isSelectOption(currentOption) || currentOption.disabled) {
+            errorMessage = "This option is disabled";
+          } else {
+            if (selectedOptions.has(pointer)) {
+              selectedOptions.delete(pointer);
+            } else {
+              selectedOptions.add(pointer);
+            }
+            errorMessage = "";
+          }
+          renderOptions();
+          break;
+        }
+        case "return":
+          void confirmSelection();
+          break;
+        case "c":
+          if (key.ctrl) {
+            void endPrompt(true);
+          }
+          break;
+        case "a":
+          toggleSelectAll();
+          errorMessage = "";
+          renderOptions();
+          break;
+      }
+    }
+    input.on("keypress", handleKeypress);
+  });
+}

package/bin/core-impl/select/nummultiselect-prompt.d.ts

@@ -0,0 +1,6 @@
+import type { PromptOptions } from "../../core-types.js";
+type NumMultiSelectPromptOptions = PromptOptions & {
+    defaultValue?: string[];
+};
+export declare function numMultiSelectPrompt(opts: NumMultiSelectPromptOptions): Promise<any>;
+export {};

package/bin/core-impl/select/nummultiselect-prompt.js

@@ -0,0 +1,105 @@
+import { re } from "@reliverse/relico";
+import { stdin as input, stdout as output } from "node:process";
+import readline from "node:readline/promises";
+import { bar, fmt, msg } from "../msg-fmt/messages.js";
+import {
+  countLines,
+  deleteLastLine,
+  deleteLastLines
+} from "../msg-fmt/terminal.js";
+export async function numMultiSelectPrompt(opts) {
+  const {
+    title = "",
+    choices,
+    defaultValue,
+    titleColor = "cyan",
+    titleTypography = "none",
+    titleVariant,
+    hint,
+    hintPlaceholderColor = "blue",
+    content,
+    contentColor = "dim",
+    contentTypography = "italic",
+    contentVariant,
+    borderColor = "dim",
+    variantOptions
+  } = opts;
+  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 { text: question } = fmt({
+        hintPlaceholderColor,
+        type: errorMessage !== "" ? "M_ERROR" : "M_GENERAL",
+        title: `${title}${defaultValue ? ` [Default: ${Array.isArray(defaultValue) ? defaultValue.join(", ") : defaultValue}]` : ""}`,
+        titleColor,
+        titleTypography,
+        titleVariant: titleVariant ?? "none",
+        content: content ?? "",
+        contentColor: contentColor ?? "dim",
+        contentTypography: contentTypography ?? "none",
+        contentVariant: contentVariant ?? "none",
+        borderColor,
+        hint: hint ?? "",
+        variantOptions: variantOptions ?? {},
+        errorMessage
+      });
+      const choicesText = choices.map(
+        (choice, index) => re.dim(
+          `${formattedBar}  ${index + 1}) ${choice.title}${choice.description ? ` - ${choice.description}` : ""}`
+        )
+      ).join("\n");
+      const fullPrompt = `${question}
+${choicesText}
+${formattedBar}  ${re.bold(re.blue(`Enter your choices (comma-separated numbers between 1-${choices.length})`))}:
+${formattedBar}  `;
+      const { text: formattedPrompt } = fmt({
+        hintPlaceholderColor,
+        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: "none"
+        });
+        msg({ type: "M_BAR", borderColor });
+        return defaultValue;
+      }
+      const selections = answer.split(",").map((s) => s.trim());
+      const invalidSelections = selections.filter((s) => {
+        const num = Number(s);
+        return Number.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);
+      const isValid = true;
+      errorMessage = "";
+      if (isValid) {
+        rl.close();
+        msg({ type: "M_BAR", borderColor });
+        return selectedValues;
+      }
+    }
+  } finally {
+    rl.close();
+  }
+}

package/bin/core-impl/select/numselect-prompt.d.ts

@@ -0,0 +1,7 @@
+import type { PromptOptions } from "../../core-types.js";
+type NumSelectPromptOptions = PromptOptions & {
+    inline?: boolean;
+    defaultValue?: string;
+};
+export declare function numSelectPrompt(opts: NumSelectPromptOptions): Promise<any>;
+export {};