@reliverse/rempts 1.6.2 → 1.7.1

package/bin/{core-impl → components}/input/input-prompt.js

@@ -1,14 +1,10 @@
 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 { 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";
+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) {

package/bin/{core-impl → components}/launcher/deprecated/_parser.ts.txt

@@ -2,7 +2,7 @@ import type {
   Default,
   ParserArgv,
   ParserOptions,
-} from "~/libs/core/core-types.js";
+} from "~/types.js";
 
 function toArr(any: any) {
   // biome-ignore lint/suspicious/noDoubleEquals: <explanation>

package/bin/{core-impl → components}/launcher/deprecated/_utils.ts.txt

@@ -1,4 +1,4 @@
-import type { Resolvable } from "~/libs/core/core-types.js";
+import type { Resolvable } from "~/types.js";
 
 export function toArray(val: any) {
   if (Array.isArray(val)) {

package/bin/{core-impl → components}/launcher/deprecated/args.ts.txt

@@ -1,6 +1,6 @@
 import { kebabCase, camelCase } from "scule";
 
-import type { Arg, ArgsDef, ParsedArgs } from "~/libs/core/core-types.js";
+import type { Arg, ArgsDef, ParsedArgs } from "~/types.js";
 
 import { parseRawArgs } from "./_parser.js";
 import { CLIError, toArray } from "./_utils.js";

package/bin/{core-impl → components}/launcher/deprecated/command.ts.txt

@@ -3,7 +3,7 @@ import type {
   CommandContext,
   CommandDef,
   RunCommandOptions,
-} from "~/libs/core/core-types.js";
+} from "~/types.js";
 
 import { CLIError, resolveValue } from "./_utils.js";
 import { parseArgs } from "./args.js";

package/bin/{core-impl → components}/launcher/deprecated/launcher-mod.ts.txt

@@ -1,6 +1,6 @@
 import { relinka } from "@reliverse/relinka";
 
-import type { ArgsDef, CommandDef } from "~/libs/core/core-types.js";
+import type { ArgsDef, CommandDef } from "~/types.js";
 
 import { CLIError } from "./_utils.js";
 import { resolveSubCommand, runCommand } from "./command.js";

package/bin/{core-impl → components}/launcher/deprecated/usage.ts.txt

@@ -1,7 +1,7 @@
 import { re } from "@reliverse/relico";
 import { relinka } from "@reliverse/relinka";
 
-import type { ArgsDef, CommandDef } from "~/libs/core/core-types.js";
+import type { ArgsDef, CommandDef } from "~/types.js";
 
 import { formatLineColumns, resolveValue } from "./_utils.js";
 import { resolveArgs } from "./args.js";

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

@@ -0,0 +1,177 @@
+import type { ReliArgParserOptions } from "@reliverse/reliarg";
+type InvalidDefaultError<O extends readonly string[]> = {
+    __error__: "Default value(s) must be a subset of options";
+    options: O;
+};
+type EmptyArgs = Record<string, never>;
+type BaseArgProps = {
+    description?: string;
+    required?: boolean;
+};
+type PositionalArgDefinition = {
+    type: "positional";
+    default?: string;
+} & BaseArgProps;
+type BooleanArgDefinition = {
+    type: "boolean";
+    default?: boolean;
+} & BaseArgProps;
+type StringArgDefinition = {
+    type: "string";
+    default?: string;
+} & BaseArgProps;
+type NumberArgDefinition = {
+    type: "number";
+    default?: number;
+} & BaseArgProps;
+type ArrayArgDefinition = {
+    type: "array";
+    default?: string | readonly string[];
+    options: readonly string[];
+} & BaseArgProps;
+export type ArgDefinition = PositionalArgDefinition | BooleanArgDefinition | StringArgDefinition | NumberArgDefinition | ArrayArgDefinition;
+export type ArgDefinitions = Record<string, ArgDefinition>;
+type CommandMeta = {
+    name: string;
+    version?: string;
+    description?: string;
+    hidden?: boolean;
+    aliases?: string[];
+};
+/**
+ * A subcommand can be either:
+ * 1) A string path to a module with a default export of type Command.
+ * 2) A lazy import function returning a Promise that resolves to
+ *    { default: Command<any> } or directly to a Command instance.
+ */
+type SubCommandSpec = string | (() => Promise<{
+    default: Command<any>;
+} | Command<any>>);
+export type SubCommandsMap = Record<string, SubCommandSpec>;
+type CommandContext<ARGS> = {
+    args: ARGS;
+    raw: string[];
+};
+type CommandRun<ARGS> = (ctx: CommandContext<ARGS>) => void | Promise<void>;
+type DefineCommandOptions<A extends ArgDefinitions = EmptyArgs> = {
+    meta?: CommandMeta;
+    args?: A;
+    run?: CommandRun<InferArgTypes<A>>;
+    subCommands?: SubCommandsMap;
+    /**
+     * Called before the command or subcommand runs
+     */
+    onCmdStart?: () => void | Promise<void>;
+    /**
+     * Called after the command or subcommand finishes
+     */
+    onCmdEnd?: () => void | Promise<void>;
+    /**
+     * @deprecated Use onCmdStart instead
+     */
+    setup?: () => void | Promise<void>;
+    /**
+     * @deprecated Use onCmdEnd instead
+     */
+    cleanup?: () => void | Promise<void>;
+    /**
+     * Called once per CLI process, before any command/subcommand/run() is executed
+     */
+    onLauncherStart?: () => void | Promise<void>;
+    /**
+     * Called once per CLI process, after all command/subcommand/run() logic is finished
+     */
+    onLauncherEnd?: () => void | Promise<void>;
+};
+export type Command<A extends ArgDefinitions = EmptyArgs> = {
+    meta?: CommandMeta;
+    args: A;
+    run?: CommandRun<InferArgTypes<A>>;
+    subCommands?: SubCommandsMap;
+    /**
+     * Called before the command or subcommand runs
+     */
+    onCmdStart?: () => void | Promise<void>;
+    /**
+     * Called after the command or subcommand finishes
+     */
+    onCmdEnd?: () => void | Promise<void>;
+    /**
+     * @deprecated Use onCmdStart instead
+     */
+    setup?: () => void | Promise<void>;
+    /**
+     * @deprecated Use onCmdEnd instead
+     */
+    cleanup?: () => void | Promise<void>;
+    /**
+     * Called once per CLI process, before any command/subcommand/run() is executed
+     */
+    onLauncherStart?: () => void | Promise<void>;
+    /**
+     * Called once per CLI process, after all command/subcommand/run() logic is finished
+     */
+    onLauncherEnd?: () => void | Promise<void>;
+};
+export type InferArgTypes<A extends ArgDefinitions> = {
+    [K in keyof A]: A[K] extends PositionalArgDefinition ? string : A[K] extends BooleanArgDefinition ? boolean : A[K] extends StringArgDefinition ? string : A[K] extends NumberArgDefinition ? number : A[K] extends {
+        type: "array";
+        options: infer O extends readonly string[];
+    } ? O[number][] : never;
+};
+type ValidateArrayDefaults<A extends ArgDefinitions> = {
+    [K in keyof A]: A[K] extends {
+        type: "array";
+        options: infer O extends readonly string[];
+        default?: infer D;
+    } ? D extends undefined ? A[K] : D extends O[number] ? A[K] : D extends readonly (infer E)[] ? E extends O[number] ? A[K] : Omit<A[K], "default"> & {
+        default: InvalidDefaultError<O>;
+    } : Omit<A[K], "default"> & {
+        default: InvalidDefaultError<O>;
+    } : A[K];
+};
+export type FileBasedCmdsOptions = {
+    enable: boolean;
+    cmdsRootPath: string;
+};
+/**
+ * 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 & {
+    fileBasedCmds?: FileBasedCmdsOptions;
+    autoExit?: boolean;
+    metaSettings?: {
+        showDescriptionOnMain?: boolean;
+    };
+}, displayNotFoundMessage?: boolean): Promise<void>;
+/**
+ * Primary entry point to run a command. This function supports:
+ *
+ * - File-based Subcommands: scanning for subcommands within a given commands root.
+ * - SubCommands defined within the command object.
+ * - Standard flags like --help, --version, and --debug.
+ *
+ * This function passes along remaining arguments to subcommand runners to ensure
+ * consistent parsing.
+ */
+export declare function runMain<A extends ArgDefinitions = EmptyArgs>(command: Command<A>, parserOptions?: ReliArgParserOptions & {
+    fileBasedCmds?: FileBasedCmdsOptions;
+    autoExit?: boolean;
+    metaSettings?: {
+        showDescriptionOnMain?: boolean;
+    };
+}): Promise<void>;
+/**
+ * Helper to define argument definitions with improved type inference
+ * for IntelliSense and validation for array defaults against options.
+ *
+ * **Note:** For array types, use `as const` on the `options` array to enable
+ * precise default value validation (e.g., `options: ["a", "b"] as const`).
+ */
+export declare function defineArgs<A extends ArgDefinitions>(args: A & ValidateArrayDefaults<A>): A;
+export {};