@reliverse/rempts 1.7.11 → 1.7.13

package/package.json

@@ -1,21 +1,22 @@
 {
   "dependencies": {
     "@figliolia/chalk-animation": "^1.0.4",
+    "@reliverse/pathkit": "^1.2.1",
     "@reliverse/reliarg": "^1.0.3",
     "@reliverse/relico": "^1.1.2",
-    "@reliverse/relinka": "^1.4.5",
+    "@reliverse/relinka": "^1.4.7",
     "@reliverse/runtime": "^1.0.3",
     "ansi-escapes": "^7.0.0",
-    "c12": "^3.0.3",
+    "c12": "^3.0.4",
     "cli-spinners": "^3.2.0",
     "detect-package-manager": "^3.0.2",
     "figlet": "^1.8.1",
     "fs-extra": "^11.3.0",
     "gradient-string": "^3.0.0",
+    "jiti": "^2.4.2",
     "log-update": "^6.1.0",
     "node-emoji": "^2.2.0",
     "ora": "^8.2.0",
-    "pathe": "^2.0.3",
     "pkg-types": "^2.1.0",
     "sisteransi": "^1.0.5",
     "terminal-kit": "^3.1.2",
@@ -28,7 +29,7 @@
   "license": "MIT",
   "name": "@reliverse/rempts",
   "type": "module",
-  "version": "1.7.11",
+  "version": "1.7.13",
   "author": "reliverse",
   "bugs": {
     "email": "blefnk@gmail.com",
@@ -41,28 +42,7 @@
     "type": "git",
     "url": "git+https://github.com/reliverse/rempts.git"
   },
-  "devDependencies": {
-    "@biomejs/biome": "1.9.4",
-    "@eslint/js": "^9.26.0",
-    "@reliverse/dler": "^1.2.5",
-    "@reliverse/relidler-cfg": "^1.1.3",
-    "@stylistic/eslint-plugin": "^4.2.0",
-    "@total-typescript/ts-reset": "^0.6.1",
-    "@types/bun": "^1.2.13",
-    "@types/figlet": "^1.7.0",
-    "@types/fs-extra": "^11.0.4",
-    "@types/node": "^22.15.18",
-    "@types/terminal-kit": "^2.5.7",
-    "@types/wrap-ansi": "^8.1.0",
-    "eslint": "^9.26.0",
-    "eslint-plugin-no-relative-import-paths": "^1.6.1",
-    "eslint-plugin-perfectionist": "^4.13.0",
-    "jiti": "^2.4.2",
-    "knip": "^5.56.0",
-    "typescript": "^5.8.3",
-    "typescript-eslint": "^8.32.1",
-    "vitest": "^3.1.3"
-  },
+  "devDependencies": {},
   "exports": {
     ".": "./bin/mod.js"
   },
@@ -77,4 +57,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/bin/components/launcher/deprecated/_parser.ts.txt

@@ -1,167 +0,0 @@
-import type {
-  Default,
-  ParserArgv,
-  ParserOptions,
-} from "~/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/components/launcher/deprecated/_utils.ts.txt

@@ -1,41 +0,0 @@
-import type { Resolvable } from "~/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/components/launcher/deprecated/args.ts.txt

@@ -1,108 +0,0 @@
-import { kebabCase, camelCase } from "scule";
-
-import type { Arg, ArgsDef, ParsedArgs } from "~/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;
-}

package/bin/components/launcher/deprecated/command.ts.txt

@@ -1,95 +0,0 @@
-import type {
-  ArgsDef,
-  CommandContext,
-  CommandDef,
-  RunCommandOptions,
-} from "~/types.js";
-
-import { CLIError, resolveValue } from "./_utils.js";
-import { parseArgs } from "./args.js";
-
-export function defineCommand<const T extends ArgsDef = ArgsDef>(
-  def: CommandDef<T>,
-): CommandDef<T> {
-  return def;
-}
-
-export async function runCommand<T extends ArgsDef = ArgsDef>(
-  cmd: CommandDef<T>,
-  opts: RunCommandOptions,
-): Promise<{ result: unknown }> {
-  const cmdArgs = await resolveValue(cmd.args || {});
-  const parsedArgs = parseArgs<T>(opts.rawArgs, cmdArgs);
-
-  const context: CommandContext<T> = {
-    rawArgs: opts.rawArgs,
-    args: parsedArgs,
-    data: opts.data,
-    cmd,
-  };
-
-  // Setup hook
-  if (typeof cmd.setup === "function") {
-    await cmd.setup(context);
-  }
-
-  // Handle sub command
-  let result: unknown;
-  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) {
-        // biome-ignore lint/style/noUnusedTemplateLiteral: <explanation>
-        throw new CLIError(`No command specified.`, "E_NO_COMMAND");
-      }
-    }
-
-    // Handle main 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<T extends ArgsDef = ArgsDef>(
-  cmd: CommandDef<T>,
-  rawArgs: string[],
-  parent?: CommandDef<T>,
-): Promise<[CommandDef<T>, CommandDef<T>?]> {
-  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];
-}

package/bin/components/launcher/deprecated/launcher-mod.ts.txt

@@ -1,50 +0,0 @@
-import { relinka } from "@reliverse/relinka";
-
-import type { ArgsDef, CommandDef } from "~/types.js";
-
-import { CLIError } from "./_utils.js";
-import { resolveSubCommand, runCommand } from "./command.js";
-import { showUsage as _showUsage } from "./usage.js";
-
-export type RunMainOptions = {
-  rawArgs?: string[];
-  showUsage?: typeof _showUsage;
-};
-
-export async function runMain<T extends ArgsDef = ArgsDef>(
-  cmd: CommandDef<T>,
-  opts: RunMainOptions = {},
-) {
-  const rawArgs = opts.rawArgs || process.argv.slice(2);
-  const showUsage = opts.showUsage || _showUsage;
-  try {
-    if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
-      await showUsage(...(await resolveSubCommand(cmd, rawArgs)));
-      process.exit(0);
-    } else if (rawArgs.length === 1 && rawArgs[0] === "--version") {
-      const meta =
-        typeof cmd.meta === "function" ? await cmd.meta() : await cmd.meta;
-      if (!meta?.version) {
-        throw new CLIError("No version specified", "E_NO_VERSION");
-      }
-      relinka("log", meta.version);
-    } else {
-      await runCommand(cmd, { rawArgs });
-    }
-  } catch (error: any) {
-    const isCLIError = error instanceof CLIError;
-    if (isCLIError) {
-      await showUsage(...(await resolveSubCommand(cmd, rawArgs)));
-      relinka("error", error.message);
-    } else {
-      relinka("error", error, "\n");
-    }
-    process.exit(1);
-  }
-}
-
-export function createMain<T extends ArgsDef = ArgsDef>(
-  cmd: CommandDef<T>,
-): (opts?: RunMainOptions) => Promise<void> {
-  return (opts: RunMainOptions = {}) => runMain(cmd, opts);
-}

package/bin/components/launcher/deprecated/usage.ts.txt

@@ -1,157 +0,0 @@
-import { re } from "@reliverse/relico";
-import { relinka } from "@reliverse/relinka";
-
-import type { ArgsDef, CommandDef } from "~/types.js";
-
-import { formatLineColumns, resolveValue } from "./_utils.js";
-import { resolveArgs } from "./args.js";
-
-export async function showUsage<T extends ArgsDef = ArgsDef>(
-  cmd: CommandDef<T>,
-  parent?: CommandDef<T>,
-) {
-  try {
-    // biome-ignore lint/style/useTemplate: <explanation>
-    relinka("log", (await renderUsage(cmd, parent)) + "\n");
-  } catch (error) {
-    relinka("error", String(error));
-  }
-}
-
-// `no` prefix matcher (kebab-case or camelCase)
-const negativePrefixRe = /^no[-A-Z]/;
-
-export async function renderUsage<T extends ArgsDef = ArgsDef>(
-  cmd: CommandDef<T>,
-  parent?: CommandDef<T>,
-) {
-  const cmdMeta = await resolveValue(cmd.meta || {});
-  const cmdArgs = resolveArgs(await resolveValue(cmd.args || {}));
-  const parentMeta = await resolveValue(parent?.meta || {});
-
-  const commandName =
-    (parentMeta.name ? `${parentMeta.name} ` : "") +
-    (cmdMeta.name || process.argv[1]);
-
-  const argLines: string[][] = [];
-  const posLines: string[][] = [];
-  const commandsLines: string[][] = [];
-  const usageLine = [];
-
-  for (const arg of cmdArgs) {
-    if (arg.type === "positional") {
-      const name = arg.name.toUpperCase();
-      const isRequired = arg.required !== false && arg.default === undefined;
-      // (isRequired ? " (required)" : " (optional)"
-      const defaultHint = arg.default ? `="${arg.default}"` : "";
-      posLines.push([
-        // biome-ignore lint/style/useTemplate: <explanation>
-        "`" + name + defaultHint + "`",
-        arg.description || "",
-        arg.valueHint ? `<${arg.valueHint}>` : "",
-      ]);
-      usageLine.push(isRequired ? `<${name}>` : `[${name}]`);
-    } else {
-      const isRequired = arg.required === true && arg.default === undefined;
-      const argStr =
-        [...(arg.alias || []).map((a) => `-${a}`), `--${arg.name}`].join(", ") +
-        (arg.type === "string" && (arg.valueHint || arg.default)
-          ? `=${
-              arg.valueHint ? `<${arg.valueHint}>` : `"${arg.default || ""}"`
-            }`
-          : "") +
-        (arg.type === "enum" && arg.options
-          ? `=<${arg.options.join("|")}>`
-          : "");
-      argLines.push([
-        // biome-ignore lint/style/useTemplate: <explanation>
-        "`" + argStr + (isRequired ? " (required)" : "") + "`",
-        arg.description || "",
-      ]);
-
-      /**
-       * print negative boolean arg variant usage when
-       * - enabled by default or has `negativeDescription`
-       * - not prefixed with `no-` or `no[A-Z]`
-       */
-      if (
-        arg.type === "boolean" &&
-        (arg.default === true || arg.negativeDescription) &&
-        !negativePrefixRe.test(arg.name)
-      ) {
-        const negativeArgStr = [
-          ...(arg.alias || []).map((a) => `--no-${a}`),
-          `--no-${arg.name}`,
-        ].join(", ");
-        argLines.push([
-          // biome-ignore lint/style/useTemplate: <explanation>
-          "`" + negativeArgStr + (isRequired ? " (required)" : "") + "`",
-          arg.negativeDescription || "",
-        ]);
-      }
-
-      if (isRequired) {
-        usageLine.push(argStr);
-      }
-    }
-  }
-
-  if (cmd.subCommands) {
-    const commandNames: string[] = [];
-    const subCommands = await resolveValue(cmd.subCommands);
-    for (const [name, sub] of Object.entries(subCommands)) {
-      const subCmd = await resolveValue(sub);
-      const meta = await resolveValue(subCmd?.meta);
-      if (meta?.hidden) {
-        continue;
-      }
-      commandsLines.push([`\`${name}\``, meta?.description || ""]);
-      commandNames.push(name);
-    }
-    usageLine.push(commandNames.join("|"));
-  }
-
-  const usageLines: (string | undefined)[] = [];
-
-  const version = cmdMeta.version || parentMeta.version;
-
-  usageLines.push(
-    re.gray(
-      `${cmdMeta.description} (${
-        commandName + (version ? ` v${version}` : "")
-      })`,
-    ),
-    "",
-  );
-
-  const hasOptions = argLines.length > 0 || posLines.length > 0;
-  usageLines.push(
-    `${re.underline(re.bold("USAGE"))} \`${commandName}${
-      hasOptions ? " [OPTIONS]" : ""
-    } ${usageLine.join(" ")}\``,
-    "",
-  );
-
-  if (posLines.length > 0) {
-    usageLines.push(re.underline(re.bold("ARGUMENTS")), "");
-    usageLines.push(formatLineColumns(posLines, "  "));
-    usageLines.push("");
-  }
-
-  if (argLines.length > 0) {
-    usageLines.push(re.underline(re.bold("OPTIONS")), "");
-    usageLines.push(formatLineColumns(argLines, "  "));
-    usageLines.push("");
-  }
-
-  if (commandsLines.length > 0) {
-    usageLines.push(re.underline(re.bold("COMMANDS")), "");
-    usageLines.push(formatLineColumns(commandsLines, "  "));
-    usageLines.push(
-      "",
-      `Use \`${commandName} <command> --help\` for more information about a command.`,
-    );
-  }
-
-  return usageLines.filter((l) => typeof l === "string").join("\n");
-}