@reliverse/rempts 1.7.52 → 1.7.53

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

@@ -0,0 +1,76 @@
+/**
+ * Options passed to the ReliArgParser.
+ */
+export type ReliArgParserOptions = {
+    /**
+     * A list of flags that should be treated as booleans.
+     */
+    boolean?: string[];
+    /**
+     * Whether to print a warning if an unknown flag is encountered.
+     */
+    warnOnUnknown?: boolean;
+    /**
+     * Whether encountering an unknown flag should cause a thrown error.
+     */
+    strict?: boolean;
+    /**
+     * An object that maps a flag to one or more aliases (e.g. { force: "f" } or { f: ["force", "fast"] }).
+     */
+    alias?: Record<string, string | string[]>;
+    /**
+     * Default values for flags (e.g. { force: false, count: 0 }).
+     */
+    defaults?: Record<string, unknown>;
+    /**
+     * If true, allows --no-foo to set foo=false (negated booleans).
+     * Defaults to `true`.
+     */
+    negatedBoolean?: boolean;
+    /**
+     * A callback to determine if a flag is considered "unknown."
+     * If it returns false, the parser may warn or throw, depending on config.
+     */
+    unknown?: (flagName: string) => boolean;
+    /**
+     * If true, attempt to parse non-boolean string values as numbers when possible.
+     * Defaults to false.
+     */
+    parseNumbers?: boolean;
+    /**
+     * If true, negative numbers like -123 will not be treated as short flags
+     * and will be parsed as positional values.
+     * Defaults to true (commonly desired).
+     */
+    allowNegativeNumbers?: boolean;
+    /**
+     * If true, stop parsing flags at the first positional argument,
+     * pushing all subsequent arguments into result._.
+     * Defaults to false.
+     */
+    stopEarly?: boolean;
+    /**
+     * A list of flags that should be collected as arrays if repeated.
+     * e.g. { array: ["include"] } => --include file1 --include file2
+     * results in { include: ["file1", "file2"] }
+     */
+    array?: string[];
+    /**
+     * A list of flags that should always be treated as strings (ignoring parseNumbers).
+     */
+    string?: string[];
+};
+/**
+ * The result of parsing command-line arguments.
+ */
+export type ReliArgParserResult = {
+    /**
+     * Positional arguments (non-flag arguments).
+     */
+    _: string[];
+    [key: string]: unknown;
+};
+/**
+ * Parse arguments according to the provided `ReliArgParserOptions`.
+ */
+export declare function reliArgParser(argv: string[], opts?: ReliArgParserOptions): ReliArgParserResult;

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

@@ -0,0 +1,276 @@
+const NEGATIVE_NUMBER_REGEX = /^[0-9]+(\.[0-9]+)?$/;
+function isAsciiLetter(ch) {
+  const code = ch.charCodeAt(0);
+  return code >= 65 && code <= 90 || code >= 97 && code <= 122;
+}
+export function reliArgParser(argv, opts = {}) {
+  const context = createParserContext(opts);
+  prePopulateDefaults(context);
+  let i = 0;
+  const argvLength = argv.length;
+  while (i < argvLength) {
+    const arg = argv[i];
+    if (!arg) {
+      i++;
+      continue;
+    }
+    if (context.stopEarlyTriggered) {
+      context.result._.push(arg);
+      i++;
+      continue;
+    }
+    if (arg === "--") {
+      context.result._.push(...argv.slice(i + 1));
+      break;
+    }
+    if (context.allowNegativeNumbers && isNegativeNumber(arg)) {
+      if (context.stopEarly) {
+        context.result._.push(...argv.slice(i));
+        break;
+      } else {
+        context.result._.push(arg);
+        i++;
+        continue;
+      }
+    }
+    if (shouldHandleNegatedBoolean(arg, context)) {
+      handleNegatedBooleanFlag(arg, context);
+      i++;
+      continue;
+    }
+    if (arg.length > 2 && arg[0] === "-" && arg[1] === "-") {
+      i = handleLongFlag(argv, i, context);
+      continue;
+    }
+    if (arg.length > 1 && arg[0] === "-" && arg[1] !== "-") {
+      i = handleShortFlags(argv, i, context);
+      continue;
+    }
+    if (context.stopEarly) {
+      context.result._.push(...argv.slice(i));
+      break;
+    }
+    context.result._.push(arg);
+    i++;
+  }
+  return context.result;
+}
+function createParserContext(opts) {
+  const booleanFlags = new Set(opts.boolean || []);
+  const arrayFlags = new Set(opts.array || []);
+  const stringFlags = new Set(opts.string || []);
+  const aliasMap = buildAliasMap(opts.alias || {});
+  const result = { _: [] };
+  return {
+    result,
+    booleanFlags,
+    arrayFlags,
+    stringFlags,
+    aliasMap,
+    options: opts,
+    stopEarlyTriggered: false,
+    // Cache frequently accessed options for performance
+    allowNegativeNumbers: opts.allowNegativeNumbers !== false,
+    negatedBoolean: opts.negatedBoolean !== false,
+    parseNumbers: opts.parseNumbers || false,
+    stopEarly: opts.stopEarly || false,
+    warnOnUnknown: opts.warnOnUnknown || false,
+    strict: opts.strict || false
+  };
+}
+function prePopulateDefaults(context) {
+  const { defaults = {} } = context.options;
+  for (const [key, val] of Object.entries(defaults)) {
+    context.result[key] = val;
+  }
+}
+function buildAliasMap(aliasObj) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(aliasObj)) {
+    if (Array.isArray(value)) {
+      const canonical = value[0];
+      if (canonical) {
+        map.set(key, canonical);
+        for (const alias of value) {
+          map.set(alias, canonical);
+        }
+      }
+    } else {
+      map.set(key, value);
+      map.set(value, value);
+    }
+  }
+  return map;
+}
+function isNegativeNumber(arg) {
+  if (arg.length < 2 || arg[0] !== "-") return false;
+  if (arg[1] === "-") return false;
+  return NEGATIVE_NUMBER_REGEX.test(arg.slice(1));
+}
+function shouldHandleNegatedBoolean(arg, context) {
+  return context.negatedBoolean && arg.length > 5 && arg[0] === "-" && arg[1] === "-" && arg[2] === "n" && arg[3] === "o" && arg[4] === "-";
+}
+function handleNegatedBooleanFlag(arg, context) {
+  const flagName = arg.slice(5);
+  const resolvedName = resolveFlagName(flagName, context);
+  if (context.booleanFlags.has(resolvedName)) {
+    setFlagValue(resolvedName, false, context);
+  } else {
+    handleUnknownFlag(resolvedName, context);
+  }
+}
+function handleLongFlag(argv, index, context) {
+  const arg = argv[index];
+  if (arg === void 0) {
+    return index + 1;
+  }
+  const flagBody = arg.slice(2);
+  const eqIndex = flagBody.indexOf("=");
+  let rawFlagName = flagBody;
+  let value = true;
+  let nextIndex = index;
+  if (eqIndex !== -1) {
+    rawFlagName = flagBody.slice(0, eqIndex);
+    value = flagBody.slice(eqIndex + 1);
+  } else {
+    const nextArg = argv[index + 1];
+    if (nextArg && nextArg.length > 0 && nextArg[0] !== "-") {
+      value = nextArg;
+      nextIndex++;
+    }
+  }
+  const flagName = resolveFlagName(rawFlagName, context);
+  const parsedValue = parseValue(value, flagName, context);
+  setFlagValue(flagName, parsedValue, context);
+  validateOrWarn(flagName, context);
+  return nextIndex + 1;
+}
+function handleShortFlags(argv, index, context) {
+  const arg = argv[index];
+  if (arg === void 0) {
+    return index + 1;
+  }
+  const shortFlags = arg.slice(1);
+  const booleanFlags = context.booleanFlags;
+  const aliasMap = context.aliasMap;
+  const shortFlagsLength = shortFlags.length;
+  let j = 0;
+  while (j < shortFlagsLength) {
+    const flagChar = shortFlags[j];
+    if (!flagChar) {
+      j++;
+      continue;
+    }
+    const resolvedName = aliasMap.get(flagChar) || flagChar;
+    const nextChar = shortFlags[j + 1];
+    if (booleanFlags.has(resolvedName)) {
+      if (nextChar === "=") {
+        const attachedValue = shortFlags.slice(j + 2);
+        const parsed = parseValue(attachedValue, resolvedName, context);
+        setFlagValue(resolvedName, parsed, context);
+        j = shortFlagsLength;
+      } else if (nextChar && !isAsciiLetter(nextChar)) {
+        const attachedValue = shortFlags.slice(j + 1);
+        const parsed = parseValue(attachedValue, resolvedName, context);
+        setFlagValue(resolvedName, parsed, context);
+        j = shortFlagsLength;
+      } else {
+        setFlagValue(resolvedName, true, context);
+        j++;
+      }
+    } else {
+      const remainder = shortFlags.slice(j + 1);
+      if (remainder.startsWith("=")) {
+        const val = remainder.slice(1);
+        const parsedVal = parseValue(val, resolvedName, context);
+        setFlagValue(resolvedName, parsedVal, context);
+        validateOrWarn(resolvedName, context);
+        j = shortFlagsLength;
+      } else if (remainder.length > 0) {
+        const parsedVal = parseValue(remainder, resolvedName, context);
+        setFlagValue(resolvedName, parsedVal, context);
+        validateOrWarn(resolvedName, context);
+        j = shortFlagsLength;
+      } else {
+        const nextArgIndex = index + 1;
+        if (nextArgIndex < argv.length) {
+          const nextArg = argv[nextArgIndex];
+          if (nextArg && nextArg.length > 0 && nextArg[0] !== "-") {
+            const parsedVal = parseValue(nextArg, resolvedName, context);
+            setFlagValue(resolvedName, parsedVal, context);
+            validateOrWarn(resolvedName, context);
+            return index + 2;
+          }
+        }
+        setFlagValue(resolvedName, true, context);
+        validateOrWarn(resolvedName, context);
+        break;
+      }
+    }
+  }
+  return index + 1;
+}
+function resolveFlagName(rawName, context) {
+  return context.aliasMap.get(rawName) || rawName;
+}
+function setFlagValue(flagName, value, context) {
+  if (context.arrayFlags.has(flagName)) {
+    if (!Array.isArray(context.result[flagName])) {
+      context.result[flagName] = [];
+    }
+    context.result[flagName].push(value);
+  } else {
+    context.result[flagName] = value;
+  }
+}
+function parseValue(val, flagName, context) {
+  if (typeof val === "boolean") {
+    return val;
+  }
+  const strVal = String(val);
+  if (context.stringFlags.has(flagName)) {
+    return strVal;
+  }
+  if (context.booleanFlags.has(flagName)) {
+    if (strVal === "true") return true;
+    if (strVal === "false") return false;
+    return strVal;
+  }
+  if (context.parseNumbers && strVal.length > 0) {
+    const firstChar = strVal.charAt(0);
+    const lastChar = strVal.charAt(strVal.length - 1);
+    if (firstChar >= "0" && firstChar <= "9" || firstChar === "-" || firstChar === "+") {
+      if (lastChar >= "0" && lastChar <= "9") {
+        const maybeNum = Number(strVal);
+        if (!Number.isNaN(maybeNum)) {
+          return maybeNum;
+        }
+      }
+    }
+  }
+  return strVal;
+}
+function validateOrWarn(flagName, context) {
+  const { unknown, defaults } = context.options;
+  if (unknown) {
+    if (!unknown(flagName)) {
+      handleUnknownFlag(flagName, context);
+    }
+    return;
+  }
+  if (context.booleanFlags.has(flagName) || context.arrayFlags.has(flagName) || context.stringFlags.has(flagName) || context.aliasMap.has(flagName)) {
+    return;
+  }
+  if (defaults && Object.hasOwn(defaults, flagName)) {
+    return;
+  }
+  handleUnknownFlag(flagName, context);
+}
+function handleUnknownFlag(flagName, context) {
+  if (context.strict) {
+    throw new Error(`Unknown flag: --${flagName}`);
+  }
+  if (context.warnOnUnknown) {
+    console.warn(`Unknown flag: --${flagName}`);
+  }
+}

package/bin/libs/results/results.d.ts

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

package/bin/libs/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/libs/select/nummultiselect-prompt.d.ts

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

package/bin/libs/select/nummultiselect-prompt.js

@@ -0,0 +1,101 @@
+import { stdin as input, stdout as output } from "node:process";
+import readline from "node:readline/promises";
+import { re } from "@reliverse/relico";
+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/libs/select/numselect-prompt.d.ts

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

package/bin/libs/select/numselect-prompt.js

@@ -0,0 +1,111 @@
+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";
+import { colorize } from "../utils/colorize.js";
+export async function numSelectPrompt(opts) {
+  const {
+    title = "",
+    hint,
+    hintPlaceholderColor = "blue",
+    validate,
+    defaultValue,
+    titleColor = "cyan",
+    titleTypography = "none",
+    titleVariant,
+    content,
+    contentColor = "dim",
+    contentTypography = "italic",
+    contentVariant,
+    borderColor = "dim",
+    variantOptions,
+    inline = true,
+    choices
+  } = opts;
+  if (!choices || choices.length === 0) {
+    throw new Error("Choices are required for select prompt.");
+  }
+  const rl = readline.createInterface({ input, output });
+  const formattedBar = bar({ borderColor });
+  let linesToDelete = 0;
+  let errorMessage = "";
+  while (true) {
+    if (linesToDelete > 0) {
+      deleteLastLines(linesToDelete);
+    }
+    const { text: question } = fmt({
+      hintPlaceholderColor,
+      type: errorMessage !== "" ? "M_ERROR" : "M_GENERAL",
+      title,
+      titleColor,
+      titleTypography,
+      titleVariant,
+      content,
+      contentColor,
+      contentTypography,
+      contentVariant,
+      borderColor,
+      hint,
+      variantOptions,
+      errorMessage
+    });
+    let choicesText = "";
+    if (inline) {
+      choicesText = choices.map(
+        (choice, index) => `${index + 1}) ${choice.title}${choice.description ? ` (${choice.description})` : ""}`
+      ).join(" / ");
+    } else {
+      choicesText = choices.map(
+        (choice, index) => `${index + 1}) ${choice.title}${choice.description ? ` - ${choice.description}` : ""}`
+      ).join(`
+${formattedBar} `);
+    }
+    const { text: formattedPrompt } = fmt({
+      hintPlaceholderColor,
+      type: "M_NULL",
+      title: `${question}
+${choicesText}
+${formattedBar}  ${colorize(
+        "Enter your choice:",
+        contentColor
+      )}
+${formattedBar}  `
+    });
+    const questionLines = countLines(formattedPrompt);
+    linesToDelete = questionLines + 1;
+    const prompt = await rl.question(formattedPrompt);
+    const answer = prompt.trim() || defaultValue;
+    if (!prompt.trim() && defaultValue !== void 0) {
+      deleteLastLine();
+      msg({
+        type: "M_MIDDLE",
+        title: `  ${defaultValue}`,
+        titleColor: "none"
+      });
+      msg({ type: "M_BAR", borderColor });
+    }
+    const num = Number(answer);
+    if (Number.isNaN(num) || num < 1 || num > choices.length) {
+      errorMessage = `Please enter a number between 1 and ${choices.length}.`;
+      continue;
+    }
+    const selectedChoice = choices[num - 1];
+    const selectedValue = selectedChoice?.id ?? num;
+    let isValid = true;
+    errorMessage = "";
+    if (validate && isValid) {
+      const validation = await validate(selectedValue);
+      if (validation !== true) {
+        isValid = false;
+        errorMessage = typeof validation === "string" ? validation : "Invalid input.";
+      }
+    }
+    if (isValid) {
+      rl.close();
+      if (selectedChoice?.action) {
+        await selectedChoice.action();
+      }
+      return selectedValue;
+    }
+  }
+}

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

@@ -0,0 +1,9 @@
+import type { SelectPromptParams } from "../../types";
+export declare const select: <T extends string>(params: SelectPromptParams<T>) => Promise<T>;
+export declare const selectSimple: <T extends string>(params: Omit<SelectPromptParams<T>, "options"> & {
+    options: {
+        value: T;
+        label?: string;
+        hint?: string;
+    }[];
+}) => Promise<T>;

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

@@ -0,0 +1,9 @@
+import { selectPrompt } from "../select/select-prompt.js";
+export const select = selectPrompt;
+export const selectSimple = (params) => {
+  return selectPrompt({
+    ...params,
+    optionsArray: params.options,
+    options: void 0
+  });
+};

package/bin/libs/select/select-prompt.d.ts

@@ -0,0 +1,5 @@
+import type { SelectPromptParams } from "../../types";
+/**
+ * Displays a selectable prompt in the terminal and returns the chosen value.
+ */
+export declare function selectPrompt<T extends string>(params: SelectPromptParams<T>): Promise<T>;