@reliverse/rempts 1.7.52 → 1.7.54

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

@@ -0,0 +1,372 @@
+import readline from "node:readline/promises";
+import { re } from "@reliverse/relico";
+import { isUnicodeSupported } from "@reliverse/runtime";
+import { bar, msg, msgUndoAll } from "../msg-fmt/messages.js";
+import { deleteLastLine } from "../msg-fmt/terminal.js";
+import { completePrompt } from "../utils/prompt-end.js";
+import { streamText } from "../utils/stream-text.js";
+const unicode = isUnicodeSupported();
+const S_MASK = unicode ? "\u258B" : "*";
+function getMaskChar(customMask) {
+  if (!unicode) return "*";
+  return customMask ?? S_MASK;
+}
+async function ask(terminal, prompt, mode, mask) {
+  if (mode === "password") {
+    return new Promise((resolve) => {
+      let buffer = "";
+      const maskChar = getMaskChar(mask);
+      process.stdout.write(prompt);
+      const onData = (data) => {
+        const str = data.toString("utf-8");
+        for (const char of str) {
+          if (char === "\n" || char === "\r") {
+            process.stdout.write("\n");
+            cleanup();
+            resolve(buffer);
+            return;
+          }
+          if (char === "") {
+            cleanup();
+            resolve(null);
+            return;
+          }
+          if (char === "\x7F" || char === "\b") {
+            if (buffer.length > 0) {
+              buffer = buffer.slice(0, -1);
+            }
+            redrawPrompt(buffer, prompt);
+            continue;
+          }
+          buffer += char;
+          redrawPrompt(buffer, prompt);
+        }
+      };
+      process.stdin.on("data", onData);
+      const cleanup = () => {
+        process.stdin.removeListener("data", onData);
+      };
+      const redrawPrompt = (maskedBuffer, textPrompt) => {
+        process.stdout.clearLine(0);
+        process.stdout.cursorTo(0);
+        process.stdout.write(textPrompt + maskChar.repeat(maskedBuffer.length));
+      };
+    });
+  }
+  return terminal.question(prompt);
+}
+function renderPromptUI(params) {
+  const {
+    title,
+    hint = "",
+    hintPlaceholderColor = "blue",
+    content = "",
+    contentColor = "dim",
+    contentTypography = "italic",
+    contentVariant = "none",
+    titleColor = "cyan",
+    titleTypography = "none",
+    titleVariant = "none",
+    borderColor = "dim",
+    placeholder = "",
+    userInput,
+    errorMessage,
+    symbol = "step_active",
+    customSymbol = "",
+    symbolColor = "cyan",
+    shouldStream = false,
+    streamDelay = 30
+  } = params;
+  const type = errorMessage !== "" ? "M_ERROR" : "M_GENERAL";
+  if (shouldStream) {
+    return new Promise((resolve) => {
+      msg({
+        type,
+        title: "",
+        titleColor,
+        titleTypography,
+        titleVariant,
+        content: "",
+        contentColor,
+        contentTypography,
+        contentVariant,
+        borderColor,
+        hint,
+        hintPlaceholderColor,
+        placeholder: userInput === "" ? placeholder : "",
+        errorMessage,
+        symbol,
+        customSymbol,
+        symbolColor
+      });
+      void streamText({
+        text: title || "",
+        delay: streamDelay,
+        color: titleColor,
+        newline: false
+      }).then(async () => {
+        msgUndoAll();
+        msg({
+          type,
+          ...title !== void 0 && { title },
+          titleColor,
+          titleTypography,
+          titleVariant,
+          content: "",
+          contentColor,
+          contentTypography,
+          contentVariant,
+          borderColor,
+          hint,
+          hintPlaceholderColor,
+          placeholder: userInput === "" ? placeholder : "",
+          errorMessage,
+          symbol,
+          customSymbol,
+          symbolColor
+        });
+        if (content) {
+          await streamText({
+            text: content,
+            delay: streamDelay,
+            color: contentColor,
+            newline: false
+          });
+        }
+        msgUndoAll();
+        deleteLastLine();
+        msg({
+          type,
+          ...title !== void 0 && { title },
+          titleColor,
+          titleTypography,
+          titleVariant,
+          content,
+          contentColor,
+          contentTypography,
+          contentVariant,
+          borderColor,
+          hint,
+          hintPlaceholderColor,
+          placeholder: userInput === "" ? placeholder : "",
+          errorMessage,
+          symbol,
+          customSymbol,
+          symbolColor
+        });
+        resolve();
+      });
+    });
+  }
+  msg({
+    type,
+    ...title !== void 0 && { title },
+    titleColor,
+    titleTypography,
+    titleVariant,
+    content,
+    contentColor,
+    contentTypography,
+    contentVariant,
+    borderColor,
+    hint,
+    hintPlaceholderColor,
+    placeholder: userInput === "" ? placeholder : "",
+    errorMessage,
+    symbol,
+    customSymbol,
+    symbolColor
+  });
+  if (userInput !== "") {
+    msg({ type: "M_MIDDLE", title: `  ${userInput}` });
+  }
+  return Promise.resolve();
+}
+async function validateInput(input, validate) {
+  let isValid = true;
+  let errorMessage = "";
+  if (validate && isValid) {
+    const validationResult = await validate(input);
+    if (typeof validationResult === "string") {
+      isValid = false;
+      errorMessage = validationResult;
+    } else if (validationResult === false) {
+      isValid = false;
+      errorMessage = "Invalid input.";
+    }
+  }
+  return { isValid, errorMessage };
+}
+export async function inputPrompt(options) {
+  const {
+    title,
+    message,
+    // Alias for title
+    hint,
+    hintPlaceholderColor = "blue",
+    validate,
+    defaultValue = "",
+    initialValue,
+    // Alias for defaultValue
+    titleColor = "cyan",
+    titleTypography = "none",
+    titleVariant = "none",
+    content,
+    contentColor = "dim",
+    contentTypography = "italic",
+    contentVariant = "none",
+    borderColor = "dim",
+    placeholder,
+    hardcoded,
+    endTitle = "",
+    endTitleColor = "dim",
+    border = true,
+    symbol,
+    customSymbol,
+    symbolColor,
+    mode = "plain",
+    mask,
+    shouldStream = false,
+    streamDelay = 20
+  } = options;
+  const finalTitle = message && title ? `${title}: ${message}` : message ?? title ?? "Input";
+  const finalDefaultValue = defaultValue ?? initialValue;
+  const terminal = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  async function endPrompt(isCtrlC) {
+    await completePrompt(
+      "input",
+      isCtrlC,
+      endTitle,
+      endTitleColor,
+      titleTypography,
+      titleVariant,
+      border,
+      borderColor,
+      void 0,
+      false
+    );
+    terminal.close();
+    if (isCtrlC) {
+      process.exit(0);
+    }
+  }
+  terminal.on("SIGINT", () => {
+    void endPrompt(true);
+  });
+  let currentInput = hardcoded?.userInput ?? "";
+  let errorMessage = hardcoded?.errorMessage ?? "";
+  let showPlaceholder = hardcoded?.showPlaceholder ?? true;
+  let isRerender = false;
+  async function handleHardcodedInput() {
+    msgUndoAll();
+    await renderPromptUI({
+      title: finalTitle,
+      ...hint !== void 0 && { hint },
+      ...hintPlaceholderColor !== void 0 && { hintPlaceholderColor },
+      content: content ?? "",
+      ...contentColor !== void 0 && { contentColor },
+      ...contentTypography !== void 0 && { contentTypography },
+      ...contentVariant !== void 0 && { contentVariant },
+      titleColor,
+      titleTypography,
+      ...titleVariant !== void 0 && { titleVariant },
+      borderColor,
+      placeholder: showPlaceholder && placeholder ? placeholder : "",
+      userInput: currentInput,
+      errorMessage,
+      border,
+      ...symbol !== void 0 && { symbol },
+      ...customSymbol !== void 0 && { customSymbol },
+      ...symbolColor !== void 0 && { symbolColor },
+      ...mask !== void 0 && { mask },
+      shouldStream,
+      streamDelay
+    });
+    const finalAnswer = currentInput || finalDefaultValue;
+    const validated = await validateInput(finalAnswer, validate);
+    if (!validated.isValid) {
+      terminal.close();
+      throw new Error(validated.errorMessage || "Invalid input.");
+    }
+    msg({ type: "M_MIDDLE", title: `  ${finalAnswer}` });
+    msg({ type: "M_BAR", borderColor });
+    terminal.close();
+    return finalAnswer;
+  }
+  if (hardcoded?.userInput !== void 0) {
+    return handleHardcodedInput();
+  }
+  while (true) {
+    if (isRerender) {
+      msgUndoAll();
+    }
+    const displayedUserInput = mode === "password" ? getMaskChar(mask).repeat(currentInput.length) : currentInput;
+    if (errorMessage) {
+      deleteLastLine();
+      deleteLastLine();
+    }
+    await renderPromptUI({
+      title: finalTitle,
+      ...hint !== void 0 && { hint },
+      hintPlaceholderColor,
+      content: content ?? "",
+      contentColor,
+      contentTypography,
+      ...contentVariant !== void 0 && { contentVariant },
+      titleColor,
+      titleTypography,
+      ...titleVariant !== void 0 && { titleVariant },
+      borderColor,
+      placeholder: showPlaceholder && placeholder ? placeholder : "",
+      userInput: displayedUserInput,
+      errorMessage,
+      border,
+      ...symbol !== void 0 && { symbol },
+      ...customSymbol !== void 0 && { customSymbol },
+      ...symbolColor !== void 0 && { symbolColor },
+      ...mask !== void 0 && { mask },
+      shouldStream,
+      streamDelay
+    });
+    if (errorMessage) {
+      deleteLastLine();
+    }
+    const formattedBar = bar({ borderColor });
+    const userInputRaw = await ask(terminal, `${formattedBar}  `, mode, mask);
+    isRerender = true;
+    if (userInputRaw === null) {
+      return "";
+    }
+    currentInput = userInputRaw.trim();
+    if (showPlaceholder && currentInput !== "") {
+      showPlaceholder = false;
+    }
+    const finalAnswer = currentInput || finalDefaultValue;
+    const validated = await validateInput(finalAnswer, validate);
+    if (validated.isValid) {
+      if (!currentInput && finalDefaultValue) {
+        if (mode === "password") {
+          deleteLastLine();
+          deleteLastLine();
+          msg({
+            type: "M_MIDDLE",
+            title: `  ${getMaskChar(mask).repeat(finalDefaultValue.length)}`
+          });
+        } else {
+          deleteLastLine();
+          msg({ type: "M_MIDDLE", title: `  ${re.reset(finalDefaultValue)}` });
+        }
+      }
+      if (errorMessage) {
+        deleteLastLine();
+      }
+      msg({ type: "M_BAR", borderColor });
+      terminal.close();
+      return finalAnswer;
+    }
+    errorMessage = validated.errorMessage;
+  }
+}

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

@@ -0,0 +1,3 @@
+import { introPrompt } from "../intro/intro-mod";
+export declare const startPrompt: typeof introPrompt;
+export declare const intro: typeof introPrompt;

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

@@ -0,0 +1,3 @@
+import { introPrompt } from "../intro/intro-mod.js";
+export const startPrompt = introPrompt;
+export const intro = introPrompt;

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

@@ -0,0 +1,20 @@
+import type { Fonts } from "figlet";
+import type { PreventWrongTerminalSizeOptions, PromptOptions } from "../../types";
+type StartPromptOptions = PromptOptions & {
+    clearConsole?: boolean;
+    horizontalLine?: boolean;
+    horizontalLineLength?: number;
+    packageName?: string;
+    packageVersion?: string;
+    terminalSizeOptions?: PreventWrongTerminalSizeOptions;
+    isDev?: boolean;
+    prevent?: {
+        unsupportedTTY?: boolean;
+        wrongTerminalSize?: boolean;
+        windowsHomeDirRoot?: boolean;
+    };
+    variant?: "header" | "ascii-art";
+    asciiArtFont?: Fonts;
+};
+export declare function introPrompt(optionsOrTitle: StartPromptOptions | string): Promise<void>;
+export {};

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

@@ -0,0 +1,77 @@
+import { relinka } from "@reliverse/relinka";
+import { getCurrentTerminalName } from "@reliverse/runtime";
+import { msg } from "../msg-fmt/messages.js";
+import { getExactTerminalWidth, getTerminalHeight, getTerminalWidth } from "../msg-fmt/terminal.js";
+import {
+  preventUnsupportedTTY,
+  preventWindowsHomeDirRoot,
+  preventWrongTerminalSize
+} from "../utils/prevent.js";
+import { pm, reliversePrompts } from "../utils/system.js";
+import { createAsciiArt } from "../visual/visual-mod.js";
+export async function introPrompt(optionsOrTitle) {
+  const options = typeof optionsOrTitle === "string" ? { title: optionsOrTitle } : optionsOrTitle;
+  const {
+    title = "",
+    titleColor = "inverse",
+    titleTypography = "none",
+    titleVariant,
+    borderColor = "dim",
+    clearConsole = false,
+    horizontalLine = true,
+    horizontalLineLength: initialHorizontalLineLength = 0,
+    packageName = reliversePrompts.name,
+    packageVersion = reliversePrompts.version,
+    terminalSizeOptions = {},
+    isDev = false,
+    prevent = {
+      unsupportedTTY: true,
+      wrongTerminalSize: true,
+      windowsHomeDirRoot: true
+    },
+    variant = "header",
+    asciiArtFont
+  } = options;
+  let horizontalLineLength = initialHorizontalLineLength;
+  if (prevent.windowsHomeDirRoot) {
+    preventWindowsHomeDirRoot(process.cwd());
+  }
+  if (prevent.unsupportedTTY) {
+    preventUnsupportedTTY();
+  }
+  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 (variant === "ascii-art") {
+    await createAsciiArt({
+      message: formattedTitle,
+      ...asciiArtFont !== void 0 && { font: asciiArtFont },
+      clearConsole
+    });
+    return;
+  }
+  if (horizontalLineLength === 0) {
+    const titleFullLength = titleColor === "inverse" ? `\u2800${formattedTitle}\u2800`.length + 5 : formattedTitle.length + 5;
+    horizontalLineLength = Math.max(1, exactTerminalWidth - titleFullLength);
+  }
+  if (clearConsole) {
+    relinka("clear", "");
+    relinka("log", "");
+  } else {
+    relinka("log", "");
+  }
+  msg({
+    type: "M_START",
+    title: titleColor === "inverse" ? `\u2800${formattedTitle}\u2800` : formattedTitle,
+    titleColor,
+    titleTypography,
+    ...titleVariant ? { titleVariant } : {},
+    borderColor,
+    horizontalLine,
+    horizontalLineLength
+  });
+}

package/bin/libs/launcher/command-runner.d.ts

@@ -0,0 +1,31 @@
+import type { ReliArgParserOptions } from "../reliarg/reliarg-mod";
+import type { ArgDefinitions, Command, CommandContext, EmptyArgs, InferArgTypes } from "./launcher-types";
+export interface CallCmdOptions {
+    /** Whether to automatically exit process on errors (default: false for programmatic usage) */
+    autoExit?: boolean;
+    /** Whether to show debug output */
+    debug?: boolean;
+    /** Whether to call lifecycle hooks (onCmdInit/onCmdExit) */
+    useLifecycleHooks?: boolean;
+    /** Custom parser options for argv processing */
+    parserOptions?: ReliArgParserOptions;
+}
+/**
+ * Programmatically call a defineCommand command with arguments.
+ * Fully compatible with launcher-mod.ts execution logic.
+ *
+ * @param command - The command definition created with defineCommand()
+ * @param input - Either argv array (CLI-style) or args object (programmatic style)
+ * @param options - Optional configuration for execution
+ * @returns Promise resolving to the command context
+ *
+ * @example
+ * ```ts
+ * // CLI-style with argv array
+ * const result = await callCmd(myCommand, ['--flag', 'value', 'positional']);
+ *
+ * // Programmatic style with object
+ * const result = await callCmd(myCommand, { flag: true, name: 'value' });
+ * ```
+ */
+export declare function callCmd<A extends ArgDefinitions = EmptyArgs>(command: Command<A>, input: string[] | Partial<InferArgTypes<A>>, options?: CallCmdOptions): Promise<CommandContext<InferArgTypes<A>>>;