@reliverse/rempts 1.7.65 → 2.2.7

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

@@ -1,229 +0,0 @@
-import process from "node:process";
-import { relinka, relinkaConfig } from "@reliverse/relinka";
-import { reliArgParser } from "../reliarg/reliarg-mod.js";
-export async function callCmd(command, input, options = {}) {
-  const { autoExit = false, debug = false, useLifecycleHooks = true, parserOptions = {} } = options;
-  const debugLog = (...args) => {
-    if (debug) {
-      void relinkaConfig().then(() => relinka("log", "[callCmd DEBUG]", ...args));
-    }
-  };
-  debugLog("Calling command with input:", input);
-  debugLog("Command meta:", command.meta);
-  try {
-    let ctx;
-    if (Array.isArray(input)) {
-      debugLog("Processing argv input:", input);
-      ctx = await parseArgsFromArgv(command, input, parserOptions);
-    } else {
-      debugLog("Processing object input:", input);
-      ctx = await createContextFromArgs(command, input);
-    }
-    debugLog("Created context:", ctx);
-    if (useLifecycleHooks && command.onCmdInit) {
-      debugLog("Calling onCmdInit hook");
-      await command.onCmdInit(ctx);
-    }
-    if (command.run) {
-      debugLog("Executing command run function");
-      await command.run(ctx);
-    } else {
-      const error = "Command has no run function defined";
-      debugLog(error);
-      if (autoExit) {
-        relinka("error", error);
-        process.exit(1);
-      }
-      throw new Error(error);
-    }
-    if (useLifecycleHooks && command.onCmdExit) {
-      debugLog("Calling onCmdExit hook");
-      await command.onCmdExit(ctx);
-    }
-    debugLog("Command execution completed successfully");
-    return ctx;
-  } catch (error) {
-    debugLog("Error during command execution:", error);
-    if (autoExit) {
-      relinka("error", `Error while executing command: ${String(error)}`);
-      process.exit(1);
-    }
-    throw error;
-  }
-}
-async function parseArgsFromArgv(command, argv, parserOptions) {
-  const booleanKeys = Object.keys(command.args || {}).filter(
-    (k) => command.args?.[k]?.type === "boolean"
-  );
-  const defaultMap = {};
-  for (const [argKey, def] of Object.entries(command.args || {})) {
-    if (def.type === "boolean") {
-      defaultMap[argKey] = def.default !== void 0 ? def.default : false;
-    } else if (def.default !== void 0) {
-      defaultMap[argKey] = def.type === "array" && typeof def.default === "string" ? [def.default] : def.default;
-    }
-  }
-  const mergedParserOptions = {
-    ...parserOptions,
-    boolean: [...parserOptions.boolean || [], ...booleanKeys],
-    defaults: { ...defaultMap, ...parserOptions.defaults || {} }
-  };
-  const parsed = reliArgParser(argv, mergedParserOptions);
-  const finalArgs = {};
-  const positionalKeys = Object.keys(command.args || {}).filter(
-    (k) => command.args?.[k]?.type === "positional"
-  );
-  const leftoverPositionals = [...parsed._ || []];
-  for (let i = 0; i < positionalKeys.length; i++) {
-    const key = positionalKeys[i];
-    if (!key || !command.args) continue;
-    const def = command.args[key];
-    const val = leftoverPositionals[i];
-    finalArgs[key] = val != null && def ? castArgValue(def, val, key) : def?.default;
-  }
-  const otherKeys = Object.keys(command.args || {}).filter(
-    (k) => command.args?.[k]?.type !== "positional"
-  );
-  for (const key of otherKeys) {
-    const def = command.args?.[key];
-    if (!def) continue;
-    let rawVal = parsed[key];
-    if (def.type === "array" && rawVal !== void 0 && !Array.isArray(rawVal)) {
-      rawVal = [rawVal];
-    }
-    const casted = rawVal !== void 0 ? castArgValue(def, rawVal, key) : def.default;
-    const argUsed = rawVal !== void 0 && (def.type === "boolean" ? casted === true : true);
-    if (casted == null && def.required) {
-      throw new Error(`Missing required argument: --${key}`);
-    }
-    if (argUsed && def.dependencies?.length) {
-      const missingDeps = def.dependencies.filter((d) => {
-        const depVal = parsed[d] ?? defaultMap[d];
-        return !depVal;
-      });
-      if (missingDeps.length > 0) {
-        const depsList = missingDeps.map((d) => `--${d}`).join(", ");
-        throw new Error(
-          `Argument --${key} can only be used when ${depsList} ${missingDeps.length === 1 ? "is" : "are"} set`
-        );
-      }
-    }
-    finalArgs[key] = def.type === "boolean" ? Boolean(casted) : casted;
-  }
-  return {
-    args: finalArgs,
-    raw: argv
-  };
-}
-async function createContextFromArgs(command, inputArgs) {
-  const finalArgs = {};
-  for (const [key, def] of Object.entries(command.args || {})) {
-    const inputValue = inputArgs[key];
-    let value;
-    if (inputValue !== void 0) {
-      value = castArgValue(def, inputValue, key);
-    } else if (def.default !== void 0) {
-      value = def.type === "array" && typeof def.default === "string" ? [def.default] : def.default;
-    } else if (def.type === "boolean") {
-      value = false;
-    } else {
-      value = void 0;
-    }
-    if (value == null && def.required) {
-      throw new Error(`Missing required argument: ${key}`);
-    }
-    if (value != null && def.dependencies?.length) {
-      const missingDeps = def.dependencies.filter((d) => {
-        const depVal = inputArgs[d];
-        return !depVal;
-      });
-      if (missingDeps.length > 0) {
-        const depsList = missingDeps.join(", ");
-        throw new Error(
-          `Argument '${key}' can only be used when ${depsList} ${missingDeps.length === 1 ? "is" : "are"} provided`
-        );
-      }
-    }
-    finalArgs[key] = value;
-  }
-  return {
-    args: finalArgs,
-    raw: []
-    // No raw argv for object input
-  };
-}
-function castArgValue(def, rawVal, argName) {
-  if (rawVal == null) {
-    if (def.type === "array" && typeof def.default === "string") {
-      return [def.default];
-    }
-    return def.default ?? void 0;
-  }
-  let castedValue;
-  switch (def.type) {
-    case "boolean":
-      if (typeof rawVal === "string") {
-        const lower = rawVal.toLowerCase();
-        if (lower === "true") castedValue = true;
-        else if (lower === "false") castedValue = false;
-        else castedValue = Boolean(rawVal);
-      } else {
-        castedValue = Boolean(rawVal);
-      }
-      if (def.allowed && !def.allowed.includes(castedValue)) {
-        throw new Error(
-          `Invalid value for ${argName}: ${rawVal}. Allowed values are: ${def.allowed.join(", ")}`
-        );
-      }
-      return castedValue;
-    case "string":
-      castedValue = typeof rawVal === "string" ? rawVal : String(rawVal);
-      if (def.allowed && !def.allowed.includes(castedValue)) {
-        throw new Error(
-          `Invalid value for ${argName}: ${rawVal}. Allowed values are: ${def.allowed.join(", ")}`
-        );
-      }
-      return castedValue;
-    case "number": {
-      const n = Number(rawVal);
-      if (Number.isNaN(n)) {
-        throw new Error(`Invalid number provided for ${argName}: ${rawVal}`);
-      }
-      if (def.allowed && !def.allowed.includes(n)) {
-        throw new Error(
-          `Invalid value for ${argName}: ${rawVal}. Allowed values are: ${def.allowed.join(", ")}`
-        );
-      }
-      return n;
-    }
-    case "positional":
-      castedValue = String(rawVal);
-      if (def.allowed && !def.allowed.includes(castedValue)) {
-        throw new Error(
-          `Invalid value for ${argName}: ${rawVal}. Allowed values are: ${def.allowed.join(", ")}`
-        );
-      }
-      return castedValue;
-    case "array": {
-      const arrVal = Array.isArray(rawVal) ? rawVal : [String(rawVal)];
-      const result = [];
-      for (let v of arrVal.map(String)) {
-        if (v.startsWith("[") && v.endsWith("]")) {
-          v = v.slice(1, -1);
-        }
-        const parts = v.split(/\s*,\s*/).filter(Boolean);
-        for (const p of parts) {
-          if (def.allowed && !def.allowed.includes(p)) {
-            throw new Error(
-              `Invalid value in array ${argName}: ${p}. Allowed values are: ${def.allowed.join(", ")}`
-            );
-          }
-        }
-        result.push(...parts);
-      }
-      return result;
-    }
-    default:
-      return rawVal;
-  }
-}

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;

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

@@ -1,66 +0,0 @@
-import type { ReliArgParserOptions } from "../reliarg/reliarg-mod";
-import type { ArgDefinitions, Command, DefineCommandOptions, EmptyArgs, FileBasedOptions } from "./launcher-types";
-/**
- * Defines a command with metadata, argument definitions,
- * an execution function, and (optional) subCommands.
- */
-export declare function defineCommand<A extends ArgDefinitions = EmptyArgs>(options: DefineCommandOptions<A>): Command<A>;
-/**
- * Show usage for a given command.
- */
-export declare function showUsage<A extends ArgDefinitions>(command: Command<A>, parserOptions?: ReliArgParserOptions & {
-    fileBased?: FileBasedOptions;
-    autoExit?: boolean;
-    metaSettings?: {
-        showDescriptionOnMain?: boolean;
-    };
-    _fileBasedCurrentDir?: string;
-    _fileBasedPathSegments?: string[];
-    _isSubcommand?: boolean;
-}, globalCliMeta?: {
-    name?: string;
-    version?: string;
-    description?: string;
-}): Promise<void>;
-/**
- * Primary entry point to run a command. This function supports:
- *
- * - File-based Commands: scanning for commands within a given commands root.
- * - Commands defined within the command object.
- * - Standard flags like --help, --version, and --debug.
- *
- * This function passes along remaining arguments to command runners to ensure
- * consistent parsing.
- */
-export declare function createCli<A extends ArgDefinitions = EmptyArgs>(options: Command<A> | {
-    name?: string;
-    version?: string;
-    description?: string;
-    mainCommand?: Command<A>;
-    fileBased?: FileBasedOptions;
-    autoExit?: boolean;
-    metaSettings?: {
-        showDescriptionOnMain?: boolean;
-    };
-    meta?: Command<A>["meta"];
-    args?: Command<A>["args"];
-    run?: Command<A>["run"];
-    commands?: Command<A>["commands"];
-    onCmdInit?: Command<A>["onCmdInit"];
-    onCmdExit?: Command<A>["onCmdExit"];
-    onLauncherInit?: Command<A>["onLauncherInit"];
-    onLauncherExit?: Command<A>["onLauncherExit"];
-}, legacyParserOptions?: ReliArgParserOptions & {
-    fileBased?: FileBasedOptions;
-    autoExit?: boolean;
-    metaSettings?: {
-        showDescriptionOnMain?: boolean;
-    };
-}): Promise<void> & {
-    run(_ctx?: any): Promise<void>;
-};
-/**
- * Helper to define argument definitions with improved type inference
- * for IntelliSense and validation for array defaults against options.
- */
-export declare function defineArgs<A extends ArgDefinitions>(args: A): A;