@reliverse/rempts-core 1.6.1

package/bin/core-impl/input/input-prompt.js

@@ -0,0 +1,370 @@
+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,
+    hint,
+    hintPlaceholderColor = "blue",
+    validate,
+    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 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,
+      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 || defaultValue;
+    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,
+      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 || defaultValue;
+    const validated = await validateInput(finalAnswer, validate);
+    if (validated.isValid) {
+      if (!currentInput && defaultValue) {
+        if (mode === "password") {
+          deleteLastLine();
+          deleteLastLine();
+          msg({
+            type: "M_MIDDLE",
+            title: `  ${getMaskChar(mask).repeat(defaultValue.length)}`
+          });
+        } else {
+          deleteLastLine();
+          msg({ type: "M_MIDDLE", title: `  ${re.reset(defaultValue)}` });
+        }
+      }
+      if (errorMessage) {
+        deleteLastLine();
+      }
+      msg({ type: "M_BAR", borderColor });
+      terminal.close();
+      return finalAnswer;
+    }
+    errorMessage = validated.errorMessage;
+  }
+}

package/bin/core-impl/launcher/_parser.d.ts

@@ -0,0 +1,2 @@
+import type { Default, ParserArgv, ParserOptions } from "../../core-types.js";
+export declare function parseRawArgs<T = Default>(args?: string[], opts?: ParserOptions): ParserArgv<T>;

package/bin/core-impl/launcher/_parser.js

@@ -0,0 +1,122 @@
+function toArr(any) {
+  return any == void 0 ? [] : Array.isArray(any) ? any : [any];
+}
+function toVal(out, key, val, opts) {
+  let x;
+  const old = out[key];
+  const nxt = ~opts.string.indexOf(key) ? (
+    // biome-ignore lint/suspicious/noDoubleEquals: <explanation>
+    val == void 0 || val === true ? "" : String(val)
+  ) : typeof val === "boolean" ? val : ~opts.boolean.indexOf(key) ? val === "false" ? false : val === "true" || // biome-ignore lint/style/noCommaOperator: <explanation>
+  (out._.push((x = +val, x * 0 === 0) ? x : val), !!val) : (
+    // biome-ignore lint/style/noCommaOperator: <explanation>
+    (x = +val, x * 0 === 0) ? x : val
+  );
+  out[key] = // biome-ignore lint/suspicious/noDoubleEquals: <explanation>
+  old == void 0 ? nxt : Array.isArray(old) ? old.concat(nxt) : [old, nxt];
+}
+export function parseRawArgs(args = [], opts = {}) {
+  let k;
+  let arr;
+  let arg;
+  let name;
+  let val;
+  const out = { _: [] };
+  let i = 0;
+  let j = 0;
+  let idx = 0;
+  const len = args.length;
+  const alibi = opts.alias !== void 0;
+  const strict = opts.unknown !== void 0;
+  const defaults = opts.default !== void 0;
+  opts.alias = opts.alias || {};
+  opts.string = toArr(opts.string);
+  opts.boolean = toArr(opts.boolean);
+  if (alibi) {
+    for (k in opts.alias) {
+      arr = opts.alias[k] = toArr(opts.alias[k]);
+      for (i = 0; i < arr.length; i++) {
+        (opts.alias[arr[i]] = arr.concat(k)).splice(i, 1);
+      }
+    }
+  }
+  for (i = opts.boolean.length; i-- > 0; ) {
+    arr = opts.alias[opts.boolean[i]] || [];
+    for (j = arr.length; j-- > 0; ) {
+      opts.boolean.push(arr[j]);
+    }
+  }
+  for (i = opts.string.length; i-- > 0; ) {
+    arr = opts.alias[opts.string[i]] || [];
+    for (j = arr.length; j-- > 0; ) {
+      opts.string.push(arr[j]);
+    }
+  }
+  if (defaults) {
+    for (k in opts.default) {
+      name = typeof opts.default[k];
+      arr = opts.alias[k] = opts.alias[k] || [];
+      if (opts[name] !== void 0) {
+        opts[name].push(k);
+        for (i = 0; i < arr.length; i++) {
+          opts[name].push(arr[i]);
+        }
+      }
+    }
+  }
+  const keys = strict ? Object.keys(opts.alias) : [];
+  for (i = 0; i < len; i++) {
+    arg = args[i];
+    if (arg === "--") {
+      out._ = out._.concat(args.slice(++i));
+      break;
+    }
+    for (j = 0; j < arg.length; j++) {
+      if (arg.charCodeAt(j) !== 45) {
+        break;
+      }
+    }
+    if (j === 0) {
+      out._.push(arg);
+    } else if (arg.substring(j, j + 3) === "no-") {
+      name = arg.slice(Math.max(0, j + 3));
+      if (strict && !~keys.indexOf(name)) {
+        return opts.unknown(arg);
+      }
+      out[name] = false;
+    } else {
+      for (idx = j + 1; idx < arg.length; idx++) {
+        if (arg.charCodeAt(idx) === 61) {
+          break;
+        }
+      }
+      name = arg.substring(j, idx);
+      val = arg.slice(Math.max(0, ++idx)) || i + 1 === len || // biome-ignore lint/style/useTemplate: <explanation>
+      ("" + args[i + 1]).charCodeAt(0) === 45 || args[++i];
+      arr = j === 2 ? [name] : name;
+      for (idx = 0; idx < arr.length; idx++) {
+        name = arr[idx];
+        if (strict && !~keys.indexOf(name)) {
+          return opts.unknown("-".repeat(j) + name);
+        }
+        toVal(out, name, idx + 1 < arr.length || val, opts);
+      }
+    }
+  }
+  if (defaults) {
+    for (k in opts.default) {
+      if (out[k] === void 0) {
+        out[k] = opts.default[k];
+      }
+    }
+  }
+  if (alibi) {
+    for (k in out) {
+      arr = opts.alias[k] || [];
+      while (arr.length > 0) {
+        out[arr.shift()] = out[k];
+      }
+    }
+  }
+  return out;
+}

package/bin/core-impl/launcher/_utils.d.ts

@@ -0,0 +1,8 @@
+import type { Resolvable } from "../../core-types.js";
+export declare function toArray(val: any): any[];
+export declare function formatLineColumns(lines: string[][], linePrefix?: string): string;
+export declare function resolveValue<T>(input: Resolvable<T>): T | Promise<T>;
+export declare class CLIError extends Error {
+    code?: string | undefined;
+    constructor(message: string, code?: string | undefined);
+}

package/bin/core-impl/launcher/_utils.js

@@ -0,0 +1,29 @@
+export function toArray(val) {
+  if (Array.isArray(val)) {
+    return val;
+  }
+  return val === void 0 ? [] : [val];
+}
+export function formatLineColumns(lines, linePrefix = "") {
+  const maxLength = [];
+  for (const line of lines) {
+    for (const [i, element] of line.entries()) {
+      maxLength[i] = Math.max(maxLength[i] || 0, element.length);
+    }
+  }
+  return lines.map(
+    (l) => l.map(
+      (c, i) => linePrefix + c[i === 0 ? "padStart" : "padEnd"](maxLength[i])
+    ).join("  ")
+  ).join("\n");
+}
+export function resolveValue(input) {
+  return typeof input === "function" ? input() : input;
+}
+export class CLIError extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "CLIError";
+  }
+}

package/bin/core-impl/launcher/args.d.ts

@@ -0,0 +1,3 @@
+import type { Arg, ArgsDef, ParsedArgs } from "../../core-types.js";
+export declare function parseArgs<T extends ArgsDef = ArgsDef>(rawArgs: string[], argsDef: ArgsDef): ParsedArgs<T>;
+export declare function resolveArgs(argsDef: ArgsDef): Arg[];

package/bin/core-impl/launcher/args.js

@@ -0,0 +1,89 @@
+import { kebabCase, camelCase } from "scule";
+import { parseRawArgs } from "./_parser.js";
+import { CLIError, toArray } from "./_utils.js";
+export function parseArgs(rawArgs, argsDef) {
+  const parseOptions = {
+    boolean: [],
+    string: [],
+    number: [],
+    enum: [],
+    mixed: [],
+    alias: {},
+    default: {}
+  };
+  const args = resolveArgs(argsDef);
+  for (const arg of args) {
+    if (arg.type === "positional") {
+      continue;
+    }
+    if (arg.type === "string" || arg.type === "number") {
+      parseOptions.string.push(arg.name);
+    } else if (arg.type === "boolean") {
+      parseOptions.boolean.push(arg.name);
+    } else if (arg.type === "enum") {
+      parseOptions.enum.push(...arg.options || []);
+    }
+    if (arg.default !== void 0) {
+      parseOptions.default[arg.name] = arg.default;
+    }
+    if (arg.alias) {
+      parseOptions.alias[arg.name] = arg.alias;
+    }
+  }
+  const parsed = parseRawArgs(rawArgs, parseOptions);
+  const [...positionalArguments] = parsed._;
+  const parsedArgsProxy = new Proxy(parsed, {
+    get(target, prop) {
+      return target[prop] ?? target[camelCase(prop)] ?? target[kebabCase(prop)];
+    }
+  });
+  for (const [, arg] of args.entries()) {
+    if (arg.type === "positional") {
+      const nextPositionalArgument = positionalArguments.shift();
+      if (nextPositionalArgument !== void 0) {
+        parsedArgsProxy[arg.name] = nextPositionalArgument;
+      } else if (arg.default === void 0 && arg.required !== false) {
+        throw new CLIError(
+          `Missing required positional argument: ${arg.name.toUpperCase()}`,
+          "EARG"
+        );
+      } else {
+        parsedArgsProxy[arg.name] = arg.default;
+      }
+    } else if (arg.type === "enum") {
+      const argument = parsedArgsProxy[arg.name];
+      const options = arg.options || [];
+      if (argument !== void 0 && options.length > 0 && !options.includes(argument)) {
+        throw new CLIError(
+          `Invalid value for argument: \`--${arg.name}\` (\`${argument}\`). Expected one of: ${options.map((o) => `\`${o}\``).join(", ")}.`,
+          "EARG"
+        );
+      }
+    } else if (arg.type === "number") {
+      const _originalValue = parsedArgsProxy[arg.name];
+      parsedArgsProxy[arg.name] = Number.parseFloat(
+        parsedArgsProxy[arg.name]
+      );
+      if (Number.isNaN(parsedArgsProxy[arg.name])) {
+        throw new CLIError(
+          `Invalid value for argument: \`--${arg.name}\` (\`${_originalValue}\`). Expected a number.`,
+          "EARG"
+        );
+      }
+    } else if (arg.required && parsedArgsProxy[arg.name] === void 0) {
+      throw new CLIError(`Missing required argument: --${arg.name}`, "EARG");
+    }
+  }
+  return parsedArgsProxy;
+}
+export function resolveArgs(argsDef) {
+  const args = [];
+  for (const [name, argDef] of Object.entries(argsDef || {})) {
+    args.push({
+      ...argDef,
+      name,
+      alias: toArray(argDef.alias)
+    });
+  }
+  return args;
+}

package/bin/core-impl/launcher/command.d.ts

@@ -0,0 +1,8 @@
+import type { ArgsDef, CommandDef, RunCommandOptions } from "../../core-types.js";
+export declare function defineCommand(): any;
+declare const ArgsDef: any, CommandDef: any;
+export declare function runCommand<T extends ArgsDef = ArgsDef>(cmd: CommandDef<T>, opts: RunCommandOptions): Promise<{
+    result: unknown;
+}>;
+export declare function resolveSubCommand<T extends ArgsDef = ArgsDef>(cmd: CommandDef<T>, rawArgs: string[], parent?: CommandDef<T>): Promise<[CommandDef<T>, CommandDef<T>?]>;
+export {};

package/bin/core-impl/launcher/command.js

@@ -0,0 +1,68 @@
+import { CLIError, resolveValue } from "./_utils.js";
+import { parseArgs } from "./args.js";
+export function defineCommand(def) {
+  return def;
+}
+export async function runCommand(cmd, opts) {
+  const cmdArgs = await resolveValue(cmd.args || {});
+  const parsedArgs = parseArgs(opts.rawArgs, cmdArgs);
+  const context = {
+    rawArgs: opts.rawArgs,
+    args: parsedArgs,
+    data: opts.data,
+    cmd
+  };
+  if (typeof cmd.setup === "function") {
+    await cmd.setup(context);
+  }
+  let result;
+  try {
+    const subCommands = await resolveValue(cmd.subCommands);
+    if (subCommands && Object.keys(subCommands).length > 0) {
+      const subCommandArgIndex = opts.rawArgs.findIndex(
+        (arg) => !arg.startsWith("-")
+      );
+      const subCommandName = opts.rawArgs[subCommandArgIndex];
+      if (subCommandName) {
+        if (!subCommands[subCommandName]) {
+          throw new CLIError(
+            `Unknown command \`${subCommandName}\``,
+            "E_UNKNOWN_COMMAND"
+          );
+        }
+        const subCommand = await resolveValue(subCommands[subCommandName]);
+        if (subCommand) {
+          await runCommand(subCommand, {
+            rawArgs: opts.rawArgs.slice(subCommandArgIndex + 1)
+          });
+        }
+      } else if (!cmd.run) {
+        throw new CLIError(`No command specified.`, "E_NO_COMMAND");
+      }
+    }
+    if (typeof cmd.run === "function") {
+      result = await cmd.run(context);
+    }
+  } finally {
+    if (typeof cmd.cleanup === "function") {
+      await cmd.cleanup(context);
+    }
+  }
+  return { result };
+}
+export async function resolveSubCommand(cmd, rawArgs, parent) {
+  const subCommands = await resolveValue(cmd.subCommands);
+  if (subCommands && Object.keys(subCommands).length > 0) {
+    const subCommandArgIndex = rawArgs.findIndex((arg) => !arg.startsWith("-"));
+    const subCommandName = rawArgs[subCommandArgIndex];
+    const subCommand = await resolveValue(subCommands[subCommandName]);
+    if (subCommand) {
+      return resolveSubCommand(
+        subCommand,
+        rawArgs.slice(subCommandArgIndex + 1),
+        cmd
+      );
+    }
+  }
+  return [cmd, parent];
+}