@reliverse/rempts 1.7.44 → 1.7.45

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

@@ -1,372 +0,0 @@
-import { re } from "@reliverse/relico";
-import { isUnicodeSupported } from "@reliverse/runtime";
-import readline from "node:readline/promises";
-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,
-          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,
-          titleColor,
-          titleTypography,
-          titleVariant,
-          content,
-          contentColor,
-          contentTypography,
-          contentVariant,
-          borderColor,
-          hint,
-          hintPlaceholderColor,
-          placeholder: userInput === "" ? placeholder : "",
-          errorMessage,
-          symbol,
-          customSymbol,
-          symbolColor
-        });
-        resolve();
-      });
-    });
-  }
-  msg({
-    type,
-    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,
-      hintPlaceholderColor,
-      content,
-      contentColor,
-      contentTypography,
-      contentVariant,
-      titleColor,
-      titleTypography,
-      titleVariant,
-      borderColor,
-      placeholder: showPlaceholder ? placeholder : "",
-      userInput: currentInput,
-      errorMessage,
-      border,
-      symbol,
-      customSymbol,
-      symbolColor,
-      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,
-      hintPlaceholderColor,
-      content,
-      contentColor,
-      contentTypography,
-      contentVariant,
-      titleColor,
-      titleTypography,
-      titleVariant,
-      borderColor,
-      placeholder: showPlaceholder ? placeholder : "",
-      userInput: displayedUserInput,
-      errorMessage,
-      border,
-      symbol,
-      customSymbol,
-      symbolColor,
-      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

@@ -1,2 +0,0 @@
-export declare const startPrompt: any;
-export declare const intro: any;

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

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

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

@@ -1,20 +0,0 @@
-import type { Fonts } from "figlet";
-import type { PreventWrongTerminalSizeOptions, PromptOptions } from "../../types.js";
-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

@@ -1,81 +0,0 @@
-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 {
-  preventWrongTerminalSize,
-  preventWindowsHomeDirRoot,
-  preventUnsupportedTTY
-} 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,
-      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

@@ -1,18 +0,0 @@
-import type { Command } from "./launcher-types.js";
-/**
- * Load a command from the filesystem.
- *
- * @param cmdPath - Path to the command file or directory containing cmd.ts/cmd.js
- * @returns Promise<Command> - The loaded command
- *
- * @example
- * ```ts
- * // Load a command
- * const cmd = await loadCommand("./web/cmd");
- *
- * // Use with runCmd - pass args as separate array elements
- * await runCmd(cmd, ["--dev", "true"]); // ✅ Correct
- * await runCmd(cmd, [`--dev ${isDev}`]); // ❌ Wrong - creates single string
- * ```
- */
-export declare function loadCommand(cmdPath: string): Promise<Command>;

package/bin/libs/launcher/command-runner.js

@@ -1,79 +0,0 @@
-import { resolve, dirname } from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { createJiti } from "jiti";
-import process from "node:process";
-const jiti = createJiti(import.meta.url, {
-  debug: process.env.NODE_ENV === "development",
-  fsCache: true,
-  sourceMaps: true
-});
-const COMMAND_EXTENSIONS = [".ts", ".js"];
-const COMMAND_FILENAMES = ["cmd.ts", "cmd.js"];
-const getCallerDirectory = () => {
-  const stack = new Error().stack?.split("\n") ?? [];
-  for (const line of stack) {
-    const match = /\((.*):(\d+):(\d+)\)/.exec(line) || /at (.*):(\d+):(\d+)/.exec(line);
-    if (match?.[1]) {
-      const filePath = match[1];
-      if (!filePath.includes("run-command") && !filePath.includes("@reliverse/rempts") && !filePath.includes("node_modules") && !filePath.includes("command-runner") && !filePath.includes("command-typed") && !filePath.includes("launcher-mod") && !filePath.includes("launcher-types")) {
-        return dirname(filePath);
-      }
-    }
-  }
-  return process.cwd();
-};
-const tryLoadCommand = async (path) => {
-  if (!await fs.pathExists(path)) return null;
-  try {
-    const cmd = await jiti.import(path, { default: true });
-    return cmd;
-  } catch {
-    relinka("verbose", `Failed to load ${path} as a command file`);
-    return null;
-  }
-};
-const generateCandidatePaths = async (resolvedPath) => {
-  if (!await fs.pathExists(resolvedPath)) {
-    return COMMAND_EXTENSIONS.map((ext) => `${resolvedPath}${ext}`);
-  }
-  if (await fs.isDirectory(resolvedPath)) {
-    return COMMAND_FILENAMES.map((filename) => resolve(resolvedPath, filename));
-  }
-  return [resolvedPath];
-};
-const createCommandNotFoundError = (cmdPath, searchedPaths) => new Error(
-  `No command file found for "${cmdPath}". Expected to find either:
-  - A valid command file at the specified path
-  - A directory containing cmd.ts or cmd.js  
-  - A file path that can be resolved with .ts or .js extension
-Searched paths: ${searchedPaths.join(", ")}
-Please ensure one of these exists and exports a default command.`
-);
-const createLoadError = (cmdPath, originalError) => new Error(
-  `Failed to load command from "${cmdPath}"
-For developers: Ensure the command file:
-  - Exists and is accessible
-  - Exports a default command (e.g., export default defineCommand({...}))
-  - Is a valid TypeScript/JavaScript module
-Original error: ${originalError instanceof Error ? originalError.message : String(originalError)}`
-);
-export async function loadCommand(cmdPath) {
-  try {
-    const callerDir = getCallerDirectory();
-    const normalizedPath = cmdPath.replace(/^\.\//, "");
-    const resolvedPath = resolve(callerDir, normalizedPath);
-    const candidatePaths = await generateCandidatePaths(resolvedPath);
-    for (const path of candidatePaths) {
-      const command = await tryLoadCommand(path);
-      if (command) return command;
-    }
-    throw createCommandNotFoundError(cmdPath, candidatePaths);
-  } catch (error) {
-    if (error instanceof Error && error.message.includes("No command file found")) {
-      throw error;
-    }
-    relinka("error", `Failed to load command from ${cmdPath}:`, error);
-    throw createLoadError(cmdPath, error);
-  }
-}

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

@@ -1,16 +0,0 @@
-import type { Command } from "./launcher-types";
-/**
- * Static implementation functions for the typed command system.
- * These functions are imported by the generated cmds.ts file.
- */
-export declare function argsToStringArray(args: Record<string, unknown>): string[];
-export declare function createCallCmd<TCommandArgsMap>(): Promise<(<T extends keyof TCommandArgsMap>(cmdName: T, args?: TCommandArgsMap[T]) => Promise<void>)>;
-export declare function createGetTypedCmd<TCommandArgsMap>(): Promise<(<T extends keyof TCommandArgsMap>(cmdName: T) => Promise<{
-    command: Command;
-    run: (args?: TCommandArgsMap[T]) => Promise<void>;
-}>)>;
-export declare function callCmdImpl<TCommandArgsMap>(cmdName: keyof TCommandArgsMap, args?: TCommandArgsMap[keyof TCommandArgsMap]): Promise<void>;
-export declare function getTypedCmdImpl<TCommandArgsMap>(cmdName: keyof TCommandArgsMap): Promise<{
-    command: Command;
-    run: (args?: TCommandArgsMap[keyof TCommandArgsMap]) => Promise<void>;
-}>;

package/bin/libs/launcher/command-typed.js

@@ -1,60 +0,0 @@
-import { loadCommand } from "./command-runner.js";
-import { runCmd } from "./launcher-mod.js";
-export function argsToStringArray(args) {
-  const result = [];
-  for (const [key, value] of Object.entries(args)) {
-    if (value === void 0 || value === null) continue;
-    if (typeof value === "boolean") {
-      result.push(`--${key}=${value}`);
-    } else if (Array.isArray(value)) {
-      result.push(`--${key}=${value.join(",")}`);
-    } else {
-      result.push(`--${key}=${String(value)}`);
-    }
-  }
-  return result;
-}
-export async function createCallCmd() {
-  return async function callCmd(cmdName, args) {
-    try {
-      const command = await loadCommand(cmdName);
-      const stringArgs = args ? argsToStringArray(args) : [];
-      await runCmd(command, stringArgs);
-    } catch (error) {
-      console.error(`Error running command '${String(cmdName)}':`, error);
-      throw error;
-    }
-  };
-}
-export async function createGetTypedCmd() {
-  return async function getTypedCmd(cmdName) {
-    const command = await loadCommand(cmdName);
-    return {
-      command,
-      run: async (args) => {
-        const stringArgs = args ? argsToStringArray(args) : [];
-        await runCmd(command, stringArgs);
-      }
-    };
-  };
-}
-export async function callCmdImpl(cmdName, args) {
-  try {
-    const command = await loadCommand(cmdName);
-    const stringArgs = args ? argsToStringArray(args) : [];
-    await runCmd(command, stringArgs);
-  } catch (error) {
-    console.error(`Error running command '${String(cmdName)}':`, error);
-    throw error;
-  }
-}
-export async function getTypedCmdImpl(cmdName) {
-  const command = await loadCommand(cmdName);
-  return {
-    command,
-    run: async (args) => {
-      const stringArgs = args ? argsToStringArray(args) : [];
-      await runCmd(command, stringArgs);
-    }
-  };
-}

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

@@ -1,2 +0,0 @@
-import { createCli } from "./launcher-mod";
-export declare const runMain: typeof createCli;

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

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