@reliverse/rempts 1.6.0

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/deprecated/_parser.ts.txt

@@ -0,0 +1,167 @@
+import type {
+  Default,
+  ParserArgv,
+  ParserOptions,
+} from "~/libs/core/core-types.js";
+
+function toArr(any: any) {
+  // biome-ignore lint/suspicious/noDoubleEquals: <explanation>
+  return any == undefined ? [] : 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 == undefined || 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 == undefined ? nxt : Array.isArray(old) ? old.concat(nxt) : [old, nxt];
+}
+
+export function parseRawArgs<T = Default>(
+  args: string[] = [],
+  opts: ParserOptions = {},
+): ParserArgv<T> {
+  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)) {
+        // @ts-expect-error TODO: fix ts
+        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)) {
+          // @ts-expect-error TODO: fix ts
+          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];
+      }
+    }
+  }
+
+  // @ts-expect-error TODO: fix ts
+  return out;
+}

package/bin/core-impl/launcher/deprecated/_utils.ts.txt

@@ -0,0 +1,41 @@
+import type { Resolvable } from "~/libs/core/core-types.js";
+
+export function toArray(val: any) {
+  if (Array.isArray(val)) {
+    return val;
+  }
+  return val === undefined ? [] : [val];
+}
+
+export function formatLineColumns(lines: string[][], linePrefix = "") {
+  const maxLength: number[] = [];
+  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<T>(input: Resolvable<T>): T | Promise<T> {
+  return typeof input === "function" ? (input as any)() : input;
+}
+
+export class CLIError extends Error {
+  constructor(
+    message: string,
+    public code?: string,
+  ) {
+    super(message);
+    this.name = "CLIError";
+  }
+}

package/bin/core-impl/launcher/deprecated/args.ts.txt

@@ -0,0 +1,108 @@
+import { kebabCase, camelCase } from "scule";
+
+import type { Arg, ArgsDef, ParsedArgs } from "~/libs/core/core-types.js";
+
+import { parseRawArgs } from "./_parser.js";
+import { CLIError, toArray } from "./_utils.js";
+
+export function parseArgs<T extends ArgsDef = ArgsDef>(
+  rawArgs: string[],
+  argsDef: ArgsDef,
+): ParsedArgs<T> {
+  const parseOptions = {
+    boolean: [] as string[],
+    string: [] as string[],
+    number: [] as string[],
+    enum: [] as (number | string)[],
+    mixed: [] as string[],
+    alias: {} as Record<string, string | string[]>,
+    default: {} as Record<string, boolean | number | string>,
+  };
+
+  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 !== undefined) {
+      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: ParsedArgs<any>, prop: string) {
+      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 !== undefined) {
+        parsedArgsProxy[arg.name] = nextPositionalArgument;
+      } else if (arg.default === undefined && 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 !== undefined &&
+        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] as string,
+      );
+      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] === undefined) {
+      throw new CLIError(`Missing required argument: --${arg.name}`, "EARG");
+    }
+  }
+
+  return parsedArgsProxy as ParsedArgs<T>;
+}
+
+export function resolveArgs(argsDef: ArgsDef): Arg[] {
+  const args: Arg[] = [];
+  for (const [name, argDef] of Object.entries(argsDef || {})) {
+    args.push({
+      ...argDef,
+      name,
+      alias: toArray((argDef as any).alias),
+    });
+  }
+  return args;
+}