@reliverse/dler 1.7.122 → 1.7.124

package/bin/impl/build/binary-flow.js

@@ -9,6 +9,7 @@ import {
   parseTargets,
   validateInputFile
 } from "./providers/bun/single-file.js";
+import { createMultiStepSpinner } from "../utils/spinner.js";
 function getTargetPrefix(inputFile) {
   const filename = inputFile.split("/").pop()?.split("\\").pop() || "";
   const nameWithoutExt = filename.replace(/\.[^/.]+$/, "");
@@ -107,20 +108,39 @@ export async function binary_buildFlow(_timer, _isDev, config) {
           );
         }
       } else {
-        relinka("success", `\u{1F389} Build completed! All executables available in: ${options.outdir}`);
+        relinka("success", `\u2705 Build completed! All executables available in: ${options.outdir}`);
       }
     } else {
       relinka("info", "Building targets sequentially...");
+      const shouldShowSpinner = config.displayBuildPubLogs === false;
+      let sequentialSpinner = null;
+      if (shouldShowSpinner) {
+        sequentialSpinner = createMultiStepSpinner(
+          "Binary Build Process",
+          targets.map((target) => `Building ${target}`),
+          { color: "yellow" }
+        );
+      }
       let sequentialSuccessCount = 0;
       let sequentialFailureCount = 0;
-      for (const target of targets) {
+      for (const [index, target] of targets.entries()) {
         try {
           await buildForTarget(target, inputFile, options);
           sequentialSuccessCount++;
+          if (sequentialSpinner && index < targets.length - 1) {
+            sequentialSpinner.nextStep();
+          }
         } catch (error) {
+          if (sequentialSpinner) {
+            sequentialSpinner.error(error, index);
+            return;
+          }
           sequentialFailureCount++;
         }
       }
+      if (sequentialSpinner && sequentialSuccessCount > 0) {
+        sequentialSpinner.complete(`Built ${sequentialSuccessCount} targets successfully`);
+      }
       if (sequentialFailureCount > 0) {
         if (sequentialSuccessCount === 0) {
           relinka("error", `\u274C All builds failed! No executables were generated.`);
@@ -130,8 +150,8 @@ export async function binary_buildFlow(_timer, _isDev, config) {
             `\u26A0\uFE0F  Build completed with ${sequentialFailureCount} failure(s). ${sequentialSuccessCount} executable(s) available in: ${options.outdir}`
           );
         }
-      } else {
-        relinka("success", `\u{1F389} Build completed! All executables available in: ${options.outdir}`);
+      } else if (!sequentialSpinner) {
+        relinka("success", `\u2705 Build completed! All executables available in: ${options.outdir}`);
       }
     }
     if (existsSync(options.outdir)) {

package/bin/impl/build/build-regular.js

@@ -67,9 +67,9 @@ export async function regular_buildJsrDist(isDev, isJsr, coreIsCLI, coreEntrySrc
       const transpileFormattedDuration = prettyMilliseconds(duration, {
         verbose: true
       });
-      relinka("success", `JSR distribution built in ${transpileFormattedDuration}`);
+      relinka("verbose", `JSR distribution built in ${transpileFormattedDuration}`);
     } else {
-      relinka("success", "JSR distribution built successfully");
+      relinka("verbose", "JSR distribution built successfully");
     }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -116,9 +116,9 @@ export async function regular_buildNpmDist(isDev, coreIsCLI, coreEntrySrcDir, di
       const transpileFormattedDuration = prettyMilliseconds(duration, {
         verbose: true
       });
-      relinka("success", `NPM distribution built in ${transpileFormattedDuration}`);
+      relinka("verbose", `NPM distribution built in ${transpileFormattedDuration}`);
     } else {
-      relinka("success", "NPM distribution built successfully");
+      relinka("verbose", "NPM distribution built successfully");
     }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -162,7 +162,7 @@ async function regular_bundleUsingBun(coreEntryFile, outDirBin, transpileTarget,
       verbose: true
     });
     relinka(
-      "success",
+      "verbose",
       `Regular bun build completed in ${transpileFormattedDuration} with ${buildResult.outputs.length} output file(s).`
     );
     if (buildResult.logs && buildResult.logs.length > 0) {
@@ -189,7 +189,7 @@ async function regular_bundleUsingJsr(src, dest) {
     await fs.copy(src, dest, { overwrite: true });
     relinka("verbose", `Copied directory from ${src} to ${dest}`);
     relinka(
-      "success",
+      "verbose",
       `Completed regular bundling via 'jsr' builder`
       // `${successCount} files processed, ${changedCount} modified`,
     );
@@ -248,7 +248,7 @@ async function regular_bundleUsingUnified(coreIsCLI, coreEntryFile, outDirBin, b
       verbose: true
     });
     relinka(
-      "success",
+      "verbose",
       `Regular bundle completed in ${transpileFormattedDuration} using ${builder} builder`
     );
   } catch (error) {
@@ -321,7 +321,7 @@ async function regular_performCommonBuildSteps({
 }) {
   relinka("verbose", `Performing common build steps in ${outDirBin} (regular)`);
   relinka(
-    "info",
+    "verbose",
     `[${isJsr ? "dist-jsr" : "dist-npm"}] Performing alias path conversion in ${outDirBin}`
   );
   await convertImportsAliasToRelative({
@@ -330,7 +330,10 @@ async function regular_performCommonBuildSteps({
     pathExtFilter: "js-ts-none"
   });
   if (isJsr) {
-    relinka("info", `[dist-jsr] Performing paths ext conversion in ${outDirBin} (from js to ts)`);
+    relinka(
+      "verbose",
+      `[dist-jsr] Performing paths ext conversion in ${outDirBin} (from js to ts)`
+    );
     await convertImportsExt({
       targetDir: outDirBin,
       extFrom: "js",

package/bin/impl/build/impl.d.ts

@@ -1,7 +1,7 @@
 import type { ReliverseConfig } from "../schema/mod.js";
 import type { PerfTimer } from "../types/mod.js";
 /**
- * Main entry point for the dler build process.
+ * Main entry point for the rse build process.
  * Handles building for both main project and libraries.
  * @see `src-ts/app/pub/impl.ts` for pub main function implementation.
  */

package/bin/impl/build/impl.js

@@ -6,7 +6,7 @@ import { library_buildFlow } from "./library-flow.js";
 import { regular_buildFlow } from "./regular-flow.js";
 import { PROJECT_ROOT } from "../config/constants.js";
 import { getConfigDler } from "../config/load.js";
-import { createSpinner } from "../utils/spinner.js";
+import { createMultiStepSpinner } from "../utils/spinner.js";
 import { removeDistFolders } from "../utils/utils-clean.js";
 import { handleDlerError } from "../utils/utils-error-cwd.js";
 import { dlerPostBuild, wrapper_CopyNonBuildFiles } from "./postbuild.js";
@@ -14,13 +14,23 @@ import { dlerPreBuild } from "./prebuild.js";
 export async function dlerBuild(timer, isDev, config, debugOnlyCopyNonBuildFiles, debugDontCopyNonBuildFiles, disableOwnSpinner) {
   let effectiveConfig = config;
   let shouldShowSpinner = false;
-  let spinner = null;
+  let multiStepSpinner = null;
   try {
     if (!effectiveConfig) {
       effectiveConfig = await getConfigDler();
     }
     shouldShowSpinner = effectiveConfig.displayBuildPubLogs === false && !disableOwnSpinner;
-    spinner = shouldShowSpinner ? createSpinner("Building...").start() : null;
+    const buildSteps = [
+      "Loading configuration",
+      "Cleaning previous build",
+      "Pre-build setup",
+      "Building main project",
+      "Building libraries",
+      "Building binaries",
+      "Post-build cleanup"
+    ];
+    multiStepSpinner = shouldShowSpinner ? createMultiStepSpinner("Build Process", buildSteps, { color: "blue" }) : null;
+    if (multiStepSpinner) multiStepSpinner.nextStep();
     if (effectiveConfig.logsFreshFile) {
       await fs.remove(path.join(PROJECT_ROOT, effectiveConfig.logsFileName));
     }
@@ -31,6 +41,7 @@ export async function dlerBuild(timer, isDev, config, debugOnlyCopyNonBuildFiles
       effectiveConfig.libsList,
       "dist-tmp"
     );
+    if (multiStepSpinner) multiStepSpinner.nextStep();
     if (debugOnlyCopyNonBuildFiles) {
       if (debugDontCopyNonBuildFiles) {
         relinka(
@@ -44,6 +55,7 @@ export async function dlerBuild(timer, isDev, config, debugOnlyCopyNonBuildFiles
       process.exit(0);
     }
     await dlerPreBuild(effectiveConfig);
+    if (multiStepSpinner) multiStepSpinner.nextStep();
     const tempDirs = {
       npm: "dist-tmp/tmp-npm",
       jsr: "dist-tmp/tmp-jsr",
@@ -55,19 +67,23 @@ export async function dlerBuild(timer, isDev, config, debugOnlyCopyNonBuildFiles
       libsDirSrc: tempDirs.libs
     };
     await regular_buildFlow(timer, isDev, tempConfig);
+    if (multiStepSpinner) multiStepSpinner.nextStep();
     await library_buildFlow(timer, isDev, tempConfig);
+    if (multiStepSpinner) multiStepSpinner.nextStep();
     await binary_buildFlow(timer, isDev, tempConfig);
+    if (multiStepSpinner) multiStepSpinner.nextStep();
     await dlerPostBuild(isDev, debugDontCopyNonBuildFiles);
     if (effectiveConfig.postBuildSettings?.deleteDistTmpAfterBuild) {
       await fs.remove(path.join(PROJECT_ROOT, "dist-tmp"));
     }
-    if (shouldShowSpinner && spinner) {
-      spinner.succeed("Build completed successfully!");
+    if (multiStepSpinner) {
+      multiStepSpinner.complete("Build completed successfully");
     }
     return { timer, effectiveConfig };
   } catch (error) {
-    if (shouldShowSpinner && spinner) {
-      spinner.fail("Build failed!");
+    if (multiStepSpinner) {
+      const currentStep = multiStepSpinner.getCurrentStep();
+      multiStepSpinner.error(error, currentStep);
     }
     handleDlerError(error);
   }

package/bin/impl/build/library-flow.d.ts

@@ -23,4 +23,4 @@ export declare function libraries_build(isDev: boolean, timer: PerfTimer, libsLi
 /**
  * Publishes all libs defined in config.libsList.
  */
-export declare function libraries_publish(isDev: boolean, timer: PerfTimer, libsList: Record<string, LibConfig>, distJsrDryRun: boolean, distJsrFailOnWarn: boolean, libsDirDist: string, commonPubPause: boolean, commonPubRegistry: "jsr" | "npm" | "npm-jsr", distJsrAllowDirty: boolean, distJsrSlowTypes: boolean): Promise<void>;
+export declare function libraries_publish(isDev: boolean, timer: PerfTimer, libsList: Record<string, LibConfig>, distJsrDryRun: boolean, distJsrFailOnWarn: boolean, libsDirDist: string, commonPubPause: boolean, commonPubRegistry: "jsr" | "npm" | "npm-jsr", distJsrAllowDirty: boolean, distJsrSlowTypes: boolean, shouldShowSpinner?: boolean): Promise<void>;

package/bin/impl/build/library-flow.js

@@ -4,6 +4,7 @@ import pAll from "p-all";
 import { library_buildLibrary } from "./build-library.js";
 import { CONCURRENCY_DEFAULT, PROJECT_ROOT } from "../config/constants.js";
 import { library_publishLibrary } from "../pub/pub-library.js";
+import { createSpinnerGroup } from "../utils/spinner.js";
 import { resumePerfTimer } from "../utils/utils-perf.js";
 export async function library_buildFlow(timer, isDev, config) {
   relinka("verbose", "\u2014 \u2014 \u2014 library_buildFlow \u2014 \u2014 \u2014");
@@ -51,7 +52,8 @@ export async function library_pubFlow(timer, isDev, config) {
     config.commonPubPause,
     config.commonPubRegistry,
     config.distJsrAllowDirty,
-    config.distJsrSlowTypes
+    config.distJsrSlowTypes,
+    config.displayBuildPubLogs === false
   );
 }
 function extractFolderName(libName, libConfig) {
@@ -76,8 +78,22 @@ export async function libraries_build(isDev, timer, libsList, libsDirDist, libsD
     return;
   }
   const libsEntries = Object.entries(libsList);
-  const tasks = libsEntries.map(([libName, libConfig]) => {
+  const shouldShowSpinner = config.displayBuildPubLogs === false;
+  let spinnerGroup = null;
+  if (shouldShowSpinner) {
+    const libraryNames = libsEntries.map(([libName]) => `Building ${libName}`);
+    spinnerGroup = createSpinnerGroup({
+      items: libraryNames,
+      concurrent: true,
+      color: "green"
+    });
+    for (const spinner of spinnerGroup.spinners) {
+      spinner.start();
+    }
+  }
+  const tasks = libsEntries.map(([libName, libConfig], index) => {
     return async () => {
+      const librarySpinner = spinnerGroup?.spinners[index];
       try {
         if (!libConfig.libMainFile) {
           throw new Error(`Library ${libName} is missing "libMainFile" property.`);
@@ -132,7 +148,14 @@ export async function libraries_build(isDev, timer, libsList, libsDirDist, libsD
           transpileStub,
           transpileWatch
         });
+        if (librarySpinner) {
+          librarySpinner.succeed(`${libName} built successfully`);
+        }
       } catch (error) {
+        if (librarySpinner) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          librarySpinner.fail(`${libName} build failed: ${errorMessage}`);
+        }
         relinka(
           "error",
           `Failed to build library ${libName}: ${error instanceof Error ? error.message : String(error)}`
@@ -151,15 +174,30 @@ export async function libraries_build(isDev, timer, libsList, libsDirDist, libsD
     throw error;
   }
 }
-export async function libraries_publish(isDev, timer, libsList, distJsrDryRun, distJsrFailOnWarn, libsDirDist, commonPubPause, commonPubRegistry, distJsrAllowDirty, distJsrSlowTypes) {
+export async function libraries_publish(isDev, timer, libsList, distJsrDryRun, distJsrFailOnWarn, libsDirDist, commonPubPause, commonPubRegistry, distJsrAllowDirty, distJsrSlowTypes, shouldShowSpinner = false) {
   relinka("verbose", "Starting libraries_publish");
   if (!libsList || Object.keys(libsList).length === 0) {
     relinka("verbose", "No lib configs found in config, skipping libs publish.");
     return;
   }
   const libsEntries = Object.entries(libsList);
-  const tasks = libsEntries.map(([libName, libConfig]) => {
+  let publishSpinnerGroup = null;
+  if (!commonPubPause) {
+    const libraryNames = libsEntries.filter(([, libConfig]) => !libConfig.libPubPause).map(([libName]) => `Publishing ${libName} to ${commonPubRegistry}`);
+    if (libraryNames.length > 0) {
+      publishSpinnerGroup = createSpinnerGroup({
+        items: libraryNames,
+        concurrent: true,
+        color: "magenta"
+      });
+      for (const spinner of publishSpinnerGroup.spinners) {
+        spinner.start();
+      }
+    }
+  }
+  const tasks = libsEntries.map(([libName, libConfig], index) => {
     return async () => {
+      const publishSpinner = publishSpinnerGroup?.spinners[index];
       try {
         const folderName = extractFolderName(libName, libConfig);
         const libBaseDir = path.resolve(PROJECT_ROOT, libsDirDist, folderName);
@@ -177,12 +215,23 @@ export async function libraries_publish(isDev, timer, libsList, distJsrDryRun, d
             distJsrAllowDirty,
             distJsrSlowTypes,
             isDev,
-            timer
+            timer,
+            shouldShowSpinner
           );
+          if (publishSpinner) {
+            publishSpinner.succeed(`${libName} published to ${effectivePubRegistry} successfully`);
+          }
         } else if (libConfig.libPubPause && !commonPubPause) {
           relinka("verbose", `Publishing is paused for lib ${libName} (libPubPause: true)`);
+          if (publishSpinner) {
+            publishSpinner.info(`${libName} publish paused by configuration`);
+          }
         }
       } catch (error) {
+        if (publishSpinner) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          publishSpinner.fail(`${libName} publish failed: ${errorMessage}`);
+        }
         relinka(
           "error",
           `Failed to publish library ${libName}: ${error instanceof Error ? error.message : String(error)}`

package/bin/impl/build/providers/build.js

@@ -31,7 +31,7 @@ function shouldStopAtStep(stepNumber) {
 }
 export async function unifiedBuild(inputSourceDir, coreIsCLI, isLib, rootDir, inputConfig, outDir, transpileStub = false) {
   shouldStopAtStep(1);
-  relinka("info", "Starting unified build process...");
+  relinka("verbose", "Starting unified build process...");
   relinka("verbose", `Processing build for source directory: ${inputSourceDir}`);
   relinka(
     "verbose",
@@ -73,7 +73,7 @@ export async function unifiedBuild(inputSourceDir, coreIsCLI, isLib, rootDir, in
 }
 async function _build(rootDir, inputConfig, buildConfig, pkg, cleanedDirs, _transpileStubMode, _transpileWatchMode, outDir, showOutLog, isLib) {
   const timer = createPerfTimer();
-  relinka("info", "Resolving build configuration...");
+  relinka("verbose", "Resolving build configuration...");
   const preset = await resolvePreset(
     buildConfig.preset || pkg.dler?.preset || pkg.build?.preset || inputConfig.preset || "auto",
     rootDir
@@ -159,7 +159,7 @@ async function _build(rootDir, inputConfig, buildConfig, pkg, cleanedDirs, _tran
   relinka("verbose", `Declaration files: ${options.declaration ? "enabled" : "disabled"}`);
   options.outDir = resolve(options.rootDir, options.outDir);
   const jiti = createJiti(options.rootDir, { interopDefault: true });
-  relinka("info", "Initializing build context...");
+  relinka("verbose", "Initializing build context...");
   const ctx = {
     buildEntries: [],
     hooks: createHooks(),
@@ -180,7 +180,7 @@ async function _build(rootDir, inputConfig, buildConfig, pkg, cleanedDirs, _tran
     ctx.hooks.addHooks(buildConfig.hooks);
   }
   await ctx.hooks.callHook("build:prepare", ctx);
-  relinka("info", "Processing build entries...");
+  relinka("verbose", "Processing build entries...");
   options.entries = options.entries.map(
     (entry) => typeof entry === "string" ? { input: entry, isLib } : entry
   );
@@ -225,7 +225,7 @@ ${options.entries.map((entry) => `  ${dumpObject(entry)}`).join("\n  ")}
     );
   }
   if (options.clean) {
-    relinka("info", "Cleaning output directories...");
+    relinka("verbose", "Cleaning output directories...");
     for (const dir of new Set(
       options.entries.map((e) => e.outDir).filter((p) => !!p).sort()
     )) {
@@ -252,10 +252,10 @@ ${options.entries.map((entry) => `  ${dumpObject(entry)}`).join("\n  ")}
     return false;
   });
   if (activeTasks.length === 0) {
-    relinka("info", "No build tasks to execute");
+    relinka("verbose", "No build tasks to execute");
   } else {
     if (options.parallel) {
-      relinka("info", `Running ${activeTasks.length} build tasks in parallel...`);
+      relinka("verbose", `Running ${activeTasks.length} build tasks in parallel...`);
       await Promise.all(
         activeTasks.map(async ({ task }) => {
           await task(ctx);
@@ -263,7 +263,7 @@ ${options.entries.map((entry) => `  ${dumpObject(entry)}`).join("\n  ")}
       );
     } else {
       for (const { task, name } of activeTasks) {
-        relinka("info", `Running ${name}...`);
+        relinka("verbose", `Running ${name}...`);
         await task(ctx);
       }
     }
@@ -272,8 +272,8 @@ ${options.entries.map((entry) => `  ${dumpObject(entry)}`).join("\n  ")}
     await ctx.hooks.callHook("build:done", ctx);
     return;
   }
-  relinka("info", "Finalizing build output...");
-  relinka("success", `Build succeeded for ${options.name}`);
+  relinka("verbose", "Finalizing build output...");
+  relinka("verbose", `Build succeeded for ${options.name}`);
   const outFiles = await glob(["**"], { cwd: options.outDir });
   for (const file of outFiles) {
     let entry = ctx.buildEntries.find((e) => e.path === file);
@@ -322,9 +322,9 @@ ${entry.modules.filter((m) => m.id.includes("node_modules")).sort((a, b) => (b.b
       verbose: true
     });
     const totalSize = ctx.buildEntries.reduce((a, e) => a + (e.bytes || 0), 0);
-    relinka("info", `Build complete! ${prettyBytes(totalSize)} in ${transpileFormattedTime}`);
+    relinka("verbose", `Build complete! ${prettyBytes(totalSize)} in ${transpileFormattedTime}`);
     relinka(
-      "info",
+      "verbose",
       `\u03A3 Total dist size: ${prettyBytes(totalSize)} (build time: ${transpileFormattedTime})`
     );
   }
@@ -346,6 +346,6 @@ ${[...ctx.warnings].map((msg) => `- ${msg}`).join("\n")}`
       process.exit(1);
     }
     shouldStopAtStep(15);
-    relinka("info", `Build complete (with ${ctx.warnings.size} warnings)`);
+    relinka("verbose", `Build complete (with ${ctx.warnings.size} warnings)`);
   }
 }

package/bin/impl/build/providers/mkdist/mkdist-impl/make.js

@@ -180,7 +180,7 @@ export async function mkdist(options = {}) {
       relinka("error", `... and ${errors.length - 5} more errors`);
     }
   } else {
-    relinka("success", "Build completed successfully!");
+    relinka("verbose", "Build completed successfully!");
   }
   return {
     result: {

package/bin/impl/build/providers/mkdist/mkdist-mod.js

@@ -85,7 +85,7 @@ ${error.errors.map((e) => `  - ${e}`).join("\n")}`
     );
   } else {
     relinka(
-      "success",
+      "verbose",
       `Successfully processed ${entries.length} entries. ${totalWrittenFiles} files written.`
     );
   }