@reliverse/rempts 1.7.10 → 1.7.12

package/bin/components/launcher/launcher-mod.js

@@ -1,4 +1,5 @@
 import { reliArgParser } from "@reliverse/reliarg";
+import { re } from "@reliverse/relico";
 import { relinka, relinkaConfig, relinkaShutdown } from "@reliverse/relinka";
 import fs from "fs-extra";
 import process from "node:process";
@@ -101,29 +102,49 @@ async function getDefaultCliNameAndVersion() {
     return { name: "cli", version: void 0 };
   }
 }
-async function findDirectFileBasedSubcommands(currentDir) {
+async function findRecursiveFileBasedCommands(baseDir, currentPath = []) {
   const results = [];
-  const items = await fs.readdir(currentDir, { withFileTypes: true });
+  const items = await fs.readdir(path.join(baseDir, ...currentPath), {
+    withFileTypes: true
+  });
   for (const dirent of items) {
     if (dirent.isDirectory()) {
+      const newPath = [...currentPath, dirent.name];
       for (const fname of ["cmd.ts", "cmd.js"]) {
-        const fpath = path.join(currentDir, dirent.name, fname);
+        const fpath = path.join(baseDir, ...newPath, fname);
         if (await fs.pathExists(fpath)) {
           try {
             const imported = await import(path.resolve(fpath));
             if (imported.default && !imported.default.meta?.hidden) {
-              results.push({ name: dirent.name, def: imported.default });
+              results.push({
+                name: dirent.name,
+                def: imported.default,
+                path: newPath
+              });
             }
           } catch (err) {
-            debugLog(`Skipping file-based subcommand in ${fpath}:`, err);
+            debugLog(`Skipping file-based command in ${fpath}:`, err);
           }
           break;
         }
       }
+      const subResults = await findRecursiveFileBasedCommands(baseDir, newPath);
+      results.push(...subResults);
     }
   }
   return results;
 }
+function calculatePadding(items, minPad = 2) {
+  const maxLength = items.reduce(
+    (max, item) => Math.max(max, item.text.length),
+    0
+  );
+  return maxLength + minPad;
+}
+function formatTableRow(text, desc, padding) {
+  const spaces = " ".repeat(Math.max(0, padding - text.length));
+  return `${text}${spaces}| ${desc || ""}`;
+}
 export async function showUsage(command, parserOptions = {}) {
   const { name: fallbackName, version: fallbackVersion } = await getDefaultCliNameAndVersion();
   const cliName = command.meta?.name || fallbackName;
@@ -146,36 +167,64 @@ export async function showUsage(command, parserOptions = {}) {
   const fileCmds = parserOptions.fileBasedCmds;
   if (fileCmds?.enable) {
     const commandsDir = path.resolve(fileCmds.cmdsRootPath);
-    const currentDir = parserOptions._fileBasedCurrentDir || commandsDir;
     const pathSegments = parserOptions._fileBasedPathSegments || [];
     let usageLine = [pkgName, ...pathSegments].join(" ");
-    const directSubs = await findDirectFileBasedSubcommands(currentDir);
-    if (directSubs.length > 0) {
+    const allCommands = await findRecursiveFileBasedCommands(
+      commandsDir,
+      pathSegments
+    );
+    const directCommands = allCommands.filter(
+      (cmd) => cmd.path.length === pathSegments.length + 1
+    );
+    if (directCommands.length > 0) {
       usageLine += " <command> [command's options]";
     } else {
       usageLine += " [command's options]";
       const pos = renderPositional(command.args);
       if (pos) usageLine += ` ${pos}`;
     }
-    relinka("log", `Usage: ${usageLine}`);
-    if (directSubs.length > 0) {
-      const randomIdx = Math.floor(Math.random() * directSubs.length);
-      const { name: exampleCmd, def: exampleDef } = directSubs[randomIdx];
+    relinka("log", re.cyan(`Usage: ${usageLine}`));
+    if (directCommands.length > 0) {
+      const randomIdx = Math.floor(Math.random() * allCommands.length);
+      const { path: path2, def: exampleDef } = allCommands[randomIdx];
       const exampleArgs = buildExampleArgs(exampleDef.args || {});
       relinka(
         "log",
-        `Example: ${pkgName} ${[...pathSegments, exampleCmd].join(" ")}${exampleArgs ? ` ${exampleArgs}` : ""}`
+        re.cyan(
+          `Example: ${pkgName} ${path2.join(" ")}${exampleArgs ? ` ${exampleArgs}` : ""}`
+        )
       );
     }
-    if (directSubs.length > 0) {
+    if (allCommands.length > 0) {
       relinka("info", "Available commands (run with `help` to see more):");
-      directSubs.forEach(({ name, def }) => {
-        const desc = def?.meta?.description ?? "";
-        relinka(
-          "log",
-          `\u2022 ${[...pathSegments, name].join(" ")}${desc ? ` | ${desc}` : ""}`
-        );
-      });
+      const commandsByPath = /* @__PURE__ */ new Map();
+      for (const cmd of allCommands) {
+        const parentPath = cmd.path.slice(0, -1).join("/") || "/";
+        if (!commandsByPath.has(parentPath)) {
+          commandsByPath.set(parentPath, []);
+        }
+        commandsByPath.get(parentPath).push(cmd);
+      }
+      const groupPaddings = /* @__PURE__ */ new Map();
+      for (const [parentPath, cmds] of commandsByPath) {
+        const items = cmds.map(({ path: path2, def }) => ({
+          text: `${parentPath === "/" ? "" : "  "}\u2022 ${path2.join(" ")}`,
+          desc: def?.meta?.description
+        }));
+        groupPaddings.set(parentPath, calculatePadding(items));
+      }
+      for (const [parentPath, cmds] of commandsByPath) {
+        if (parentPath !== "/") {
+          relinka("log", re.cyanPastel(`Sub-commands in ${parentPath}:`));
+        }
+        const padding = groupPaddings.get(parentPath);
+        for (const { def, path: path2 } of cmds) {
+          const desc = def?.meta?.description ?? "";
+          const indent = parentPath === "/" ? "" : "  ";
+          const text = `${indent}\u2022 ${path2.join(" ")}`;
+          relinka("log", formatTableRow(text, desc, padding));
+        }
+      }
     }
   } else {
     const subCommandNames = [];
@@ -204,46 +253,57 @@ export async function showUsage(command, parserOptions = {}) {
     } else {
       usageLine += ` [command's options] ${renderPositional(command.args)}`;
     }
-    relinka("log", `Usage: ${usageLine}`);
+    relinka("log", re.cyan(`Usage: ${usageLine}`));
     if (subCommandDefs.length > 0) {
       const randomIdx = Math.floor(Math.random() * subCommandDefs.length);
       const { name: exampleCmd, def: exampleDef } = subCommandDefs[randomIdx];
       const exampleArgs = buildExampleArgs(exampleDef.args || {});
       relinka(
         "log",
-        `Example: ${pkgName}${parserOptions._isSubcommand ? ` ${cliName}` : ""} ${exampleCmd}${exampleArgs ? ` ${exampleArgs}` : ""}`
+        re.cyan(
+          `Example: ${pkgName}${parserOptions._isSubcommand ? ` ${cliName}` : ""} ${exampleCmd}${exampleArgs ? ` ${exampleArgs}` : ""}`
+        )
       );
     }
     if (subCommandNames.length > 0) {
       relinka("info", "Available commands (run with `help` to see more):");
-      subCommandDefs.forEach(({ name, def }) => {
-        const desc = def?.meta?.description ?? "";
-        relinka("log", `\u2022 ${name}${desc ? ` | ${desc}` : ""}`);
-      });
+      const commandItems = subCommandDefs.map(({ name, def }) => ({
+        text: `\u2022 ${name}`,
+        desc: def?.meta?.description
+      }));
+      const padding = calculatePadding(commandItems);
+      for (const { text, desc } of commandItems) {
+        relinka("log", formatTableRow(text, desc, padding));
+      }
     }
   }
   relinka("info", "Available options:");
-  relinka("log", "\u2022 -h, --help    | Show help");
-  relinka("log", "\u2022 -v, --version | Show version");
-  relinka("log", "\u2022 --debug       | Enable debug mode");
+  const optionItems = [
+    { text: "\u2022 -h, --help", desc: "Show help" },
+    { text: "\u2022 -v, --version", desc: "Show version" },
+    { text: "\u2022 --debug", desc: "Enable debug mode" }
+  ];
   for (const [key, def] of Object.entries(command.args || {})) {
     if (def.type === "positional") {
-      relinka(
-        "log",
-        `\u2022 <${key}>   | ${def.description ?? ""}${def.required ? " | required" : ""}`
-      );
+      optionItems.push({
+        text: `\u2022 <${key}>`,
+        desc: `${def.description ?? ""}${def.required ? " | required" : ""}`
+      });
     } else {
+      const text = `\u2022 --${key}${"alias" in def && def.alias ? `, -${def.alias}` : ""}`;
       const parts = [
-        `\u2022 --${key}${"alias" in def && def.alias ? `, -${def.alias}` : ""}`,
         def.description ?? "",
-        `type=${def.type}`
-      ];
-      if (def.default !== void 0)
-        parts.push(`default=${JSON.stringify(def.default)}`);
-      if (def.required) parts.push("required");
-      relinka("log", parts.filter(Boolean).join(" | "));
+        `type=${def.type}`,
+        def.default !== void 0 ? `default=${JSON.stringify(def.default)}` : null,
+        def.required ? "required" : null
+      ].filter(Boolean);
+      optionItems.push({ text, desc: parts.join(" | ") });
     }
   }
+  const optionsPadding = calculatePadding(optionItems);
+  for (const { text, desc } of optionItems) {
+    relinka("log", formatTableRow(text, desc, optionsPadding));
+  }
 }
 export async function runMain(command, parserOptions = {}) {
   if (typeof command.onLauncherInit === "function")

package/bin/hooks/spinner/spinner-mod.d.ts

@@ -1,20 +1,64 @@
+import { type Color, type Options as OraOptions } from "ora";
 type SpinnerOptions = {
     text: string;
+    color?: Color;
+    spinner?: OraOptions["spinner"];
+    successText?: string;
+    failText?: string;
 };
 type SpinnerControls = {
-    start: () => SpinnerControls;
+    start: (text?: string) => SpinnerControls;
     stop: () => void;
     setText: (text: string) => void;
+    succeed: (text?: string) => void;
+    fail: (text?: string) => void;
+    warn: (text?: string) => void;
+    info: (text?: string) => void;
+    isSpinning: () => boolean;
+    clear: () => void;
 };
 /**
- * Creates a terminal spinner.
+ * Creates a terminal spinner with enhanced controls and styling options.
  *
  * @example
- * \`\`\`typescript
- * const spinner = useSpinner({ text: "preparing something..." }).start();
- * // user's code
+ * ```typescript
+ * // Basic usage
+ * const spinner = useSpinner({ text: "Loading..." }).start();
  * spinner.stop();
- * \`\`\`
+ *
+ * // With custom color and spinner
+ * const spinner = useSpinner({
+ *   text: "Processing...",
+ *   color: "cyan",
+ *   spinner: "dots"
+ * }).start();
+ *
+ * // With success/failure states
+ * const spinner = useSpinner({
+ *   text: "Uploading...",
+ *   successText: "Upload complete!",
+ *   failText: "Upload failed!"
+ * }).start();
+ * try {
+ *   await uploadFile();
+ *   spinner.succeed();
+ * } catch (error) {
+ *   spinner.fail();
+ * }
+ *
+ * // Using the wrapper for async operations
+ * await useSpinner.promise(
+ *   async () => { await longOperation(); },
+ *   {
+ *     text: "Working...",
+ *     successText: "Done!",
+ *     failText: "Failed!"
+ *   }
+ * );
+ * ```
  */
 export declare function useSpinner(options: SpinnerOptions): SpinnerControls;
+export declare namespace useSpinner {
+    var promise: <T>(operation: () => Promise<T>, options: SpinnerOptions) => Promise<T>;
+}
 export {};

package/bin/hooks/spinner/spinner-mod.js

@@ -2,9 +2,18 @@ import ora from "ora";
 export function useSpinner(options) {
   let spinnerInstance = null;
   const controls = {
-    start: () => {
+    start: (text) => {
+      if (text) {
+        options.text = text;
+      }
       if (!spinnerInstance) {
-        spinnerInstance = ora(options.text);
+        spinnerInstance = ora({
+          text: options.text,
+          color: options.color,
+          spinner: options.spinner
+        });
+      } else {
+        spinnerInstance.text = options.text;
       }
       spinnerInstance.start();
       return controls;
@@ -20,7 +29,46 @@ export function useSpinner(options) {
       } else {
         options.text = text;
       }
+    },
+    succeed: (text) => {
+      if (spinnerInstance) {
+        spinnerInstance.succeed(text ?? options.successText);
+      }
+    },
+    fail: (text) => {
+      if (spinnerInstance) {
+        spinnerInstance.fail(text ?? options.failText);
+      }
+    },
+    warn: (text) => {
+      if (spinnerInstance) {
+        spinnerInstance.warn(text);
+      }
+    },
+    info: (text) => {
+      if (spinnerInstance) {
+        spinnerInstance.info(text);
+      }
+    },
+    isSpinning: () => {
+      return spinnerInstance?.isSpinning ?? false;
+    },
+    clear: () => {
+      if (spinnerInstance) {
+        spinnerInstance.clear();
+      }
     }
   };
   return controls;
 }
+useSpinner.promise = async (operation, options) => {
+  const spinner = useSpinner(options).start();
+  try {
+    const result = await operation();
+    spinner.succeed();
+    return result;
+  } catch (error) {
+    spinner.fail();
+    throw error;
+  }
+};

package/package.json

@@ -28,7 +28,7 @@
   "license": "MIT",
   "name": "@reliverse/rempts",
   "type": "module",
-  "version": "1.7.10",
+  "version": "1.7.12",
   "author": "reliverse",
   "bugs": {
     "email": "blefnk@gmail.com",
@@ -44,7 +44,7 @@
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
     "@eslint/js": "^9.26.0",
-    "@reliverse/dler": "^1.2.4",
+    "@reliverse/dler": "^1.2.5",
     "@reliverse/relidler-cfg": "^1.1.3",
     "@stylistic/eslint-plugin": "^4.2.0",
     "@total-typescript/ts-reset": "^0.6.1",