@reliverse/dler 1.7.26 → 1.7.27

package/README.md

@@ -127,7 +127,7 @@ if you run just `dler` — it will display a list of commands which you can laun
 
 ## **available commands**
 
-[agg](#1-agg) [build](#2-build) [check](#3-check) [conv](#4-conv) [copy](#6-copy) [init](#7-init) [inject](#8-inject) [libs](#9-libs) [merge](#10-merge) [migrate](#11-migrate) [pub](#12-pub) [rempts](#13-rempts) [rename](#14-rename) [spell](#15-spell) [split](#16-split) [pack](#17-pack) [unpack](#18-unpack)
+[agg](#1-agg) [build](#2-build) [check](#3-check) [conv](#4-conv) [copy](#6-copy) [init](#7-init) [inject](#8-inject) [libs](#9-libs) [merge](#10-merge) [migrate](#11-migrate) [pub](#12-pub) [rempts](#13-rempts) [rename](#14-rename) [spell](#15-magic) [split](#16-split) [pack](#17-pack) [unpack](#18-unpack)
 
 ### 1. `agg`
 
@@ -601,7 +601,7 @@ bun dler rempts --init cmd1 cmd2
 bun dler rename ...
 ```
 
-### 15. `spell`
+### 15. `magic`
 
 > Contributors: Please check the [docs/cmds/SPELLS.md](./docs/cmds/SPELLS.md) file for more technical details.
 

package/bin/app/agg/cmd.d.ts

@@ -10,7 +10,6 @@ declare const _default: import("@reliverse/rempts").Command<{
     input: {
         description: string;
         type: "string";
-        required: true;
     };
     named: {
         description: string;
@@ -20,7 +19,6 @@ declare const _default: import("@reliverse/rempts").Command<{
     out: {
         description: string;
         type: "string";
-        required: true;
     };
     recursive: {
         description: string;
@@ -69,5 +67,10 @@ declare const _default: import("@reliverse/rempts").Command<{
         description: string;
         type: "string";
     };
+    nonInteractive: {
+        description: string;
+        type: "boolean";
+        default: false;
+    };
 }>;
 export default _default;

package/bin/app/agg/cmd.js

@@ -1,5 +1,5 @@
 import path from "@reliverse/pathkit";
-import { defineArgs, defineCommand } from "@reliverse/rempts";
+import { defineArgs, defineCommand, inputPrompt } from "@reliverse/rempts";
 import { useAggregator } from "./impl.js";
 export default defineCommand({
   args: defineArgs({
@@ -13,8 +13,7 @@ export default defineCommand({
     },
     input: {
       description: "Directory containing .ts/.js files (--input <directory>)",
-      type: "string",
-      required: true
+      type: "string"
     },
     named: {
       description: "Parse each file for named exports (function/class/const/let)",
@@ -23,8 +22,7 @@ export default defineCommand({
     },
     out: {
       description: "Output aggregator file path (--out <fileName>)",
-      type: "string",
-      required: true
+      type: "string"
     },
     recursive: {
       description: "Recursively scan subdirectories (default true) (false means only scan the files in the current directory and not subdirectories)",
@@ -72,25 +70,63 @@ export default defineCommand({
     typesOut: {
       description: "Output file path for types (used when separateTypesFile is true)",
       type: "string"
+    },
+    nonInteractive: {
+      description: "Disable interactive prompts and require all arguments to be provided via flags",
+      type: "boolean",
+      default: false
     }
   }),
   async run({ args }) {
+    const resolvedArgs = { ...args };
+    if (!args.nonInteractive) {
+      if (!args.input) {
+        resolvedArgs.input = await inputPrompt({
+          title: "Enter input directory containing .ts/.js files:",
+          defaultValue: ""
+        });
+      }
+      if (!args.out) {
+        resolvedArgs.out = await inputPrompt({
+          title: "Enter output aggregator file path:",
+          defaultValue: ""
+        });
+      }
+      if (args.separateTypesFile && !args.typesOut) {
+        resolvedArgs.typesOut = await inputPrompt({
+          title: "Enter output file path for types:",
+          defaultValue: resolvedArgs.out.replace(/\.(ts|js)$/, ".types.$1")
+        });
+      }
+    } else {
+      if (!args.input) {
+        throw new Error("Missing required argument: --input");
+      }
+      if (!args.out) {
+        throw new Error("Missing required argument: --out");
+      }
+      if (args.separateTypesFile && !args.typesOut) {
+        throw new Error(
+          "Missing required argument: --typesOut (required when --separateTypesFile is true)"
+        );
+      }
+    }
     await useAggregator({
-      inputDir: path.resolve(args.input),
-      isRecursive: !!args.recursive,
-      outFile: path.resolve(args.out),
-      stripPrefix: args.strip ? path.resolve(args.strip) : "",
-      useImport: !!args.imports,
-      useNamed: !!args.named,
-      sortLines: !!args.sort,
-      headerComment: args.header || "",
-      verbose: !!args.verbose,
-      includeInternal: !!args.includeInternal,
-      internalMarker: args.internalMarker,
-      overrideFile: !!args.override,
-      fileExtensions: args.extensions.split(",").map((ext) => ext.trim()),
-      separateTypesFile: !!args.separateTypesFile,
-      typesOutFile: args.typesOut ? path.resolve(args.typesOut) : void 0
+      inputDir: path.resolve(resolvedArgs.input),
+      isRecursive: !!resolvedArgs.recursive,
+      outFile: path.resolve(resolvedArgs.out),
+      stripPrefix: resolvedArgs.strip ? path.resolve(resolvedArgs.strip) : "",
+      useImport: !!resolvedArgs.imports,
+      useNamed: !!resolvedArgs.named,
+      sortLines: !!resolvedArgs.sort,
+      headerComment: resolvedArgs.header || "",
+      verbose: !!resolvedArgs.verbose,
+      includeInternal: !!resolvedArgs.includeInternal,
+      internalMarker: resolvedArgs.internalMarker,
+      overrideFile: !!resolvedArgs.override,
+      fileExtensions: resolvedArgs.extensions.split(",").map((ext) => ext.trim()),
+      separateTypesFile: !!resolvedArgs.separateTypesFile,
+      typesOutFile: resolvedArgs.typesOut ? path.resolve(resolvedArgs.typesOut) : void 0
     });
   }
 });

package/bin/app/agg/impl.js

@@ -163,6 +163,7 @@ function buildPathRelative(filePath, inputDir, stripPrefix) {
   if (!resolved.startsWith("./") && !resolved.startsWith("../")) {
     resolved = `./${resolved}`;
   }
+  resolved = resolved.replace(/\/+/g, "/");
   return resolved;
 }
 async function collectFiles(dir, exts, recursive, ignoreDirs, verbose, includeInternal, internalMarker, outFile) {

package/bin/app/build/cmd.js

@@ -1,12 +1,12 @@
 import { defineArgs, defineCommand } from "@reliverse/rempts";
-import { dlerPub } from "../pub/impl.js";
+import { dlerBuild } from "./impl.js";
 import { ensureDlerConfig } from "../../libs/sdk/sdk-impl/config/init.js";
 import { getConfigDler } from "../../libs/sdk/sdk-impl/config/load.js";
-import { removeDistFolders } from "../../libs/sdk/sdk-mod.js";
+import { finalizeBuild } from "../../libs/sdk/sdk-mod.js";
 export default defineCommand({
   meta: {
     name: "build",
-    description: "Build the project"
+    description: "Build the project (without publishing)"
   },
   args: defineArgs({
     dev: {
@@ -17,12 +17,7 @@ export default defineCommand({
   async run({ args }) {
     await ensureDlerConfig(args.dev);
     const config = await getConfigDler();
-    await removeDistFolders(
-      config.distNpmDirName,
-      config.distJsrDirName,
-      config.libsDirDist,
-      config.libsList
-    );
-    await dlerPub(args.dev, config);
+    const { timer } = await dlerBuild(args.dev, config);
+    await finalizeBuild(timer, false, "build");
   }
 });

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

@@ -1,7 +1,10 @@
 import type { DlerConfig } from "../../libs/sdk/sdk-impl/config/types.js";
 /**
- * Main entry point for the dler build and publish process.
- * Handles building and publishing for both main project and libraries.
+ * Main entry point for the dler build process.
+ * Handles building for both main project and libraries.
  * @see `src/app/pub/impl.ts` for pub main function implementation.
  */
-export declare function dlerBuild(isDev: boolean, config?: DlerConfig): Promise<void>;
+export declare function dlerBuild(isDev: boolean, config?: DlerConfig): Promise<{
+    timer: any;
+    effectiveConfig: any;
+} | undefined>;

package/bin/app/build/impl.js

@@ -1,14 +1,14 @@
-import { bumpHandler, isBumpDisabled, setBumpDisabledValueTo } from "@reliverse/bleump";
 import path from "@reliverse/pathkit";
 import fs from "@reliverse/relifso";
 import { getConfigDler } from "../../libs/sdk/sdk-impl/config/load.js";
-import { processLibraryFlow } from "../../libs/sdk/sdk-impl/library-flow.js";
-import { processRegularFlow } from "../../libs/sdk/sdk-impl/regular-flow.js";
-import { finalizeBuildPub } from "../../libs/sdk/sdk-impl/utils/finalize.js";
+import { library_buildFlow } from "../../libs/sdk/sdk-impl/library-flow.js";
+import { regular_buildFlow } from "../../libs/sdk/sdk-impl/regular-flow.js";
 import { removeDistFolders } from "../../libs/sdk/sdk-impl/utils/utils-clean.js";
 import { PROJECT_ROOT } from "../../libs/sdk/sdk-impl/utils/utils-consts.js";
 import { handleDlerError } from "../../libs/sdk/sdk-impl/utils/utils-error-cwd.js";
 import { createPerfTimer } from "../../libs/sdk/sdk-impl/utils/utils-perf.js";
+import { dlerPostBuild } from "./postbuild.js";
+import { dlerPreBuild } from "./prebuild.js";
 export async function dlerBuild(isDev, config) {
   const timer = createPerfTimer();
   let effectiveConfig = config;
@@ -25,30 +25,11 @@ export async function dlerBuild(isDev, config) {
       effectiveConfig.libsDirDist,
       effectiveConfig.libsList
     );
-    try {
-      const bumpIsDisabled = await isBumpDisabled();
-      if (!bumpIsDisabled && !effectiveConfig.commonPubPause) {
-        await bumpHandler(
-          effectiveConfig.bumpMode,
-          false,
-          effectiveConfig.bumpFilter,
-          effectiveConfig.bumpSet
-        );
-        await setBumpDisabledValueTo(true);
-      }
-    } catch {
-      throw new Error("[.config/dler.ts] Failed to set bumpDisable to true");
-    }
-    await processRegularFlow(timer, isDev, effectiveConfig);
-    await processLibraryFlow(timer, isDev, effectiveConfig);
-    await finalizeBuildPub(
-      timer,
-      effectiveConfig.commonPubPause,
-      effectiveConfig.libsList,
-      effectiveConfig.distNpmDirName,
-      effectiveConfig.distJsrDirName,
-      effectiveConfig.libsDirDist
-    );
+    await dlerPreBuild(effectiveConfig);
+    await regular_buildFlow(timer, isDev, effectiveConfig);
+    await library_buildFlow(timer, isDev, effectiveConfig);
+    await dlerPostBuild(isDev);
+    return { timer, effectiveConfig };
   } catch (error) {
     handleDlerError(error);
   }

package/bin/app/build/postbuild.d.ts

@@ -0,0 +1 @@
+export declare function dlerPostBuild(isDev: boolean): Promise<void>;

package/bin/app/build/postbuild.js

@@ -0,0 +1,57 @@
+import path, { convertImportsAliasToRelative } from "@reliverse/pathkit";
+import { relinka } from "@reliverse/relinka";
+import { runCmd } from "@reliverse/rempts";
+import { getCheckCmd } from "../cmds.js";
+import { getConfigDler } from "../../libs/sdk/sdk-impl/config/load.js";
+import { applyMagicSpells } from "../../libs/sdk/sdk-impl/magic/ms-apply.js";
+import { resolveAllCrossLibs } from "../../libs/sdk/sdk-impl/utils/resolve-cross-libs.js";
+import { directoryExists, executeDlerHooks } from "./ppb-utils.js";
+const DIST_DIRECTORIES = ["dist-npm", "dist-jsr"];
+const ALIAS_TO_REPLACE = "~";
+const createPostBuildToolRunner = () => ({
+  "dler-check": {
+    name: "Dler Check",
+    async run() {
+      const checkCmd = await getCheckCmd();
+      await runCmd(checkCmd, ["--no-exit", "--no-progress"]);
+    }
+  }
+});
+async function processDistDirectory(dir, alias) {
+  try {
+    const binDir = path.join(dir, "bin");
+    if (await directoryExists(binDir)) {
+      await convertImportsAliasToRelative({
+        targetDir: binDir,
+        aliasToReplace: alias,
+        pathExtFilter: "js-ts-none"
+      });
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw error;
+  }
+}
+async function processDistDirectories() {
+  for (const dir of DIST_DIRECTORIES) {
+    relinka("log", `[processDistDirectory] ${dir}`);
+    await processDistDirectory(dir, ALIAS_TO_REPLACE);
+  }
+}
+export async function dlerPostBuild(isDev) {
+  await resolveAllCrossLibs();
+  if (isDev) {
+    await applyMagicSpells(["dist-jsr", "dist-npm", "dist-libs"]);
+  }
+  await processDistDirectories();
+  const config = await getConfigDler();
+  await executeDlerHooks(config?.hooksAfterBuild ?? [], "post-build");
+  if (config?.runAfterBuild?.length) {
+    const tools = createPostBuildToolRunner();
+    const availableTools = config.runAfterBuild.filter((toolName) => toolName in tools).map((toolName) => ({ toolName, ...tools[toolName] }));
+    for (const { name, run } of availableTools) {
+      relinka("log", `Running ${name}...`);
+      await run();
+    }
+  }
+}

package/bin/app/build/ppb-utils.d.ts

@@ -0,0 +1,16 @@
+export type PackageManager = "bun" | "npm" | "yarn" | "pnpm";
+export declare function getPackageManager(): Promise<PackageManager>;
+/**
+ * Checks if a command is available in the system or package.json
+ * First checks package.json dependencies, then falls back to global command detection
+ */
+export declare function isCommandAvailable(command: string): Promise<boolean>;
+/**
+ * Executes a shell command using the appropriate method based on the environment
+ */
+export declare function executeCommand(command: string): Promise<void>;
+export declare function directoryExists(dirPath: string): Promise<boolean>;
+/**
+ * Executes hooks with consistent error handling and logging
+ */
+export declare function executeDlerHooks(hooks: (() => Promise<void>)[], phase: "pre-build" | "post-build"): Promise<void>;

package/bin/app/build/ppb-utils.js

@@ -0,0 +1,99 @@
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { selectPrompt } from "@reliverse/rempts";
+import { $ } from "bun";
+import { execa } from "execa";
+import { lookpath } from "lookpath";
+import { readPackageJSON } from "pkg-types";
+const COMMAND_TO_PACKAGE = {
+  tsc: "typescript",
+  eslint: "eslint",
+  biome: "@biomejs/biome",
+  knip: "knip"
+};
+let selectedPackageManager = null;
+export async function getPackageManager() {
+  if (selectedPackageManager) return selectedPackageManager;
+  if (process.versions.bun) {
+    selectedPackageManager = "bun";
+    return selectedPackageManager;
+  }
+  const result = await selectPrompt({
+    title: "Select package manager to use for running tools:",
+    options: [
+      { label: "npm", value: "npm" },
+      { label: "yarn", value: "yarn" },
+      { label: "pnpm", value: "pnpm" }
+    ]
+  });
+  selectedPackageManager = result;
+  return selectedPackageManager;
+}
+async function isCommandInPackageJson(command) {
+  try {
+    const packageJson = await readPackageJSON();
+    const packageName = COMMAND_TO_PACKAGE[command];
+    if (!packageName) return false;
+    return packageName in (packageJson.dependencies || {}) || packageName in (packageJson.devDependencies || {});
+  } catch (error) {
+    return false;
+  }
+}
+export async function isCommandAvailable(command) {
+  const packageName = COMMAND_TO_PACKAGE[command];
+  if (!packageName) return false;
+  if (await isCommandInPackageJson(command)) {
+    relinka("verbose", `[dlerPreBuild] Package "${packageName}" found in package.json`);
+    return true;
+  }
+  relinka(
+    "warn",
+    `[dlerPreBuild] Package "${packageName}" not found in package.json. Consider installing it as a dependency.`
+  );
+  return await lookpath(command) !== void 0;
+}
+export async function executeCommand(command) {
+  const [firstWord, ...rest] = command.split(" ").filter(Boolean);
+  if (!firstWord) return;
+  const pkgManagers = ["bun", "yarn", "pnpm", "npm"];
+  const isPkgManager = pkgManagers.includes(firstWord);
+  const cmd = isPkgManager ? rest[0] : firstWord;
+  const args = isPkgManager ? rest.slice(1) : rest;
+  if (!cmd) return;
+  const packageName = COMMAND_TO_PACKAGE[cmd];
+  if (packageName && await isCommandInPackageJson(cmd)) {
+    const pkgManager = isPkgManager ? firstWord : await getPackageManager();
+    if (process.versions.bun) {
+      await $`${pkgManager} ${cmd} ${args.join(" ")}`;
+    } else {
+      await execa(pkgManager, [cmd, ...args], { stdio: "inherit" });
+    }
+    return;
+  }
+  if (process.versions.bun) {
+    await $`${cmd} ${args.join(" ")}`;
+  } else {
+    await execa(cmd, args, { stdio: "inherit" });
+  }
+}
+export async function directoryExists(dirPath) {
+  try {
+    return (await fs.stat(dirPath)).isDirectory();
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+}
+export async function executeDlerHooks(hooks, phase) {
+  if (!hooks.length) return;
+  relinka("log", `[dlerPreBuild] Running ${phase} hooks...`);
+  for (const hook of hooks) {
+    try {
+      await hook();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      relinka("error", `[dlerPreBuild] Error in ${phase} hook: ${message}`);
+      throw error;
+    }
+  }
+}

package/bin/app/build/prebuild.d.ts

@@ -0,0 +1,2 @@
+import type { DlerConfig } from "../../libs/sdk/sdk-impl/config/types.js";
+export declare function dlerPreBuild(config: DlerConfig): Promise<void>;

package/bin/app/build/prebuild.js

@@ -0,0 +1,50 @@
+import { relinka } from "@reliverse/relinka";
+import { runCmd } from "@reliverse/rempts";
+import { getCheckCmd } from "../cmds.js";
+import { executeCommand, executeDlerHooks, isCommandAvailable } from "./ppb-utils.js";
+const createToolRunner = () => ({
+  tsc: {
+    name: "TypeScript compiler",
+    run: () => executeCommand("tsc --noEmit")
+  },
+  eslint: {
+    name: "ESLint",
+    run: () => executeCommand("eslint --cache --fix .")
+  },
+  biome: {
+    name: "Biome",
+    run: () => executeCommand("biome check --fix --unsafe .")
+  },
+  knip: {
+    name: "Knip",
+    run: () => executeCommand("knip")
+  },
+  "dler-check": {
+    name: "Dler Check",
+    async run() {
+      const checkCmd = await getCheckCmd();
+      await runCmd(checkCmd, ["--no-exit", "--no-progress"]);
+    }
+  }
+});
+export async function dlerPreBuild(config) {
+  await executeDlerHooks(config?.hooksBeforeBuild ?? [], "pre-build");
+  if (!config?.runBeforeBuild?.length) return;
+  const tools = createToolRunner();
+  const availableTools = await Promise.all(
+    config.runBeforeBuild.map(async (toolName) => {
+      const tool = tools[toolName];
+      if (!tool) return null;
+      if (toolName === "dler-check") {
+        return { toolName, ...tool };
+      }
+      const isAvailable = await isCommandAvailable(toolName);
+      return isAvailable ? { toolName, ...tool } : null;
+    })
+  );
+  const commandsToRun = availableTools.filter(Boolean);
+  for (const { name, run } of commandsToRun) {
+    relinka("log", `Running ${name}...`);
+    await run();
+  }
+}

package/bin/app/check/cmd.d.ts

@@ -15,6 +15,14 @@ declare const _default: import("@reliverse/rempts").Command<{
         type: "boolean";
         description: string;
     };
+    "no-exit": {
+        type: "boolean";
+        description: string;
+    };
+    "no-progress": {
+        type: "boolean";
+        description: string;
+    };
     deps: {
         type: "boolean";
         description: string;