@reliverse/dler 1.7.7 → 1.7.9

package/bin/app/migrate/codemods/readdir-glob.js

@@ -27,7 +27,7 @@ export async function migrateReaddirToGlob(dryRun = false) {
   const files = await getAllTsFiles(".");
   for (const file of files) {
     try {
-      const content = await readFile(file, "utf-8");
+      const content = await readFile(file, "utf8");
       let modified = content;
       const changes = [];
       if (!content.includes("import") || !content.includes("globby")) {
@@ -37,7 +37,7 @@ export async function migrateReaddirToGlob(dryRun = false) {
       }
       const readdirRegex = /(?:await\s+)?(?:fs\.)?readdir(?:Sync)?\s*\(\s*([^)]+)\s*\)/g;
       if (readdirRegex.test(content)) {
-        modified = modified.replace(readdirRegex, (match, targetDir) => {
+        modified = modified.replace(readdirRegex, (_match, targetDir) => {
           const cleanTargetDir = targetDir.replace(/["']/g, "").trim();
           return `await globby("*", { cwd: ${cleanTargetDir}, onlyFiles: false })`;
         });
@@ -45,18 +45,15 @@ export async function migrateReaddirToGlob(dryRun = false) {
       }
       const promisesReaddirRegex = /(?:await\s+)?fs\.promises\.readdir\s*\(\s*([^)]+)\s*\)/g;
       if (promisesReaddirRegex.test(content)) {
-        modified = modified.replace(
-          promisesReaddirRegex,
-          (match, targetDir) => {
-            const cleanTargetDir = targetDir.replace(/["']/g, "").trim();
-            return `await globby("*", { cwd: ${cleanTargetDir}, onlyFiles: false })`;
-          }
-        );
+        modified = modified.replace(promisesReaddirRegex, (_match, targetDir) => {
+          const cleanTargetDir = targetDir.replace(/["']/g, "").trim();
+          return `await globby("*", { cwd: ${cleanTargetDir}, onlyFiles: false })`;
+        });
         changes.push("Converted fs.promises.readdir to globby");
       }
       if (changes.length > 0) {
         if (!dryRun) {
-          await writeFile(file, modified, "utf-8");
+          await writeFile(file, modified, "utf8");
         }
         results.push({
           file,
@@ -82,7 +79,7 @@ async function updatePackageJson(results, dryRun, config) {
   try {
     const packageJsonPath = "./package.json";
     if (existsSync(packageJsonPath)) {
-      const packageContent = await readFile(packageJsonPath, "utf-8");
+      const packageContent = await readFile(packageJsonPath, "utf8");
       const packageJson = JSON.parse(packageContent);
       let packageChanged = false;
       const packageChanges = [];
@@ -90,18 +87,14 @@ async function updatePackageJson(results, dryRun, config) {
         for (const pkg of config.remove) {
           if (packageJson.dependencies?.[pkg]) {
             packageJson.dependencies = Object.fromEntries(
-              Object.entries(packageJson.dependencies).filter(
-                ([key]) => key !== pkg
-              )
+              Object.entries(packageJson.dependencies).filter(([key]) => key !== pkg)
             );
             packageChanged = true;
             packageChanges.push(`Removed ${pkg} from dependencies`);
           }
           if (packageJson.devDependencies?.[pkg]) {
             packageJson.devDependencies = Object.fromEntries(
-              Object.entries(packageJson.devDependencies).filter(
-                ([key]) => key !== pkg
-              )
+              Object.entries(packageJson.devDependencies).filter(([key]) => key !== pkg)
             );
             packageChanged = true;
             packageChanges.push(`Removed ${pkg} from devDependencies`);
@@ -119,11 +112,7 @@ async function updatePackageJson(results, dryRun, config) {
         }
       }
       if (packageChanged && !dryRun) {
-        await writeFile(
-          packageJsonPath,
-          JSON.stringify(packageJson, null, 2),
-          "utf-8"
-        );
+        await writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2), "utf8");
       }
       if (packageChanges.length > 0) {
         results.push({

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

@@ -0,0 +1,83 @@
+declare const _default: import("@reliverse/rempts").Command<{
+    mkdistOnly: {
+        type: "boolean";
+        description: string;
+        default: true;
+    };
+    dev: {
+        type: "boolean";
+        description: string;
+    };
+    dir: {
+        type: "positional";
+        description: string;
+        default: string;
+    };
+    cwd: {
+        type: "string";
+        description: string;
+    };
+    src: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    dist: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    clean: {
+        type: "boolean";
+        description: string;
+        default: true;
+    };
+    pattern: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    format: {
+        type: "string";
+        description: string;
+    };
+    declaration: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    ext: {
+        type: "string";
+        description: string;
+    };
+    jsx: {
+        type: "string";
+        description: string;
+    };
+    jsxFactory: {
+        type: "string";
+        description: string;
+    };
+    jsxFragment: {
+        type: "string";
+        description: string;
+    };
+    loaders: {
+        type: "string";
+        description: string;
+    };
+    minify: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    target: {
+        type: "string";
+        description: string;
+    };
+    dontBuildCopyInstead: {
+        type: "string";
+        description: string;
+    };
+}>;
+export default _default;

package/bin/app/mkdist/cmd.js

@@ -0,0 +1,121 @@
+import { resolve } from "@reliverse/pathkit";
+import { defineArgs, defineCommand } from "@reliverse/rempts";
+import { dlerBuild } from "../build/impl.js";
+import { mkdist } from "../../libs/sdk/sdk-impl/build/bundlers/unified/mkdist/mkdist-impl/make.js";
+import { ensureDlerConfig } from "../../libs/sdk/sdk-impl/cfg/init.js";
+export default defineCommand({
+  meta: {
+    name: "mkdist",
+    description: "Build the project using mkdist"
+  },
+  args: defineArgs({
+    mkdistOnly: {
+      type: "boolean",
+      description: "Only run mkdist",
+      default: true
+    },
+    dev: {
+      type: "boolean",
+      description: "Runs the CLI in dev mode"
+    },
+    dir: {
+      type: "positional",
+      description: "Project root directory",
+      default: "."
+    },
+    cwd: {
+      type: "string",
+      description: "Current working directory"
+    },
+    src: {
+      type: "string",
+      description: "Source directory relative to project root directory",
+      default: "src"
+    },
+    dist: {
+      type: "string",
+      description: "Destination directory relative to project root directory",
+      default: "dist"
+    },
+    clean: {
+      type: "boolean",
+      description: "Clean the destination directory",
+      default: true
+    },
+    pattern: {
+      type: "string",
+      description: "Pattern includes or excludes files (default: '**')",
+      default: "**"
+    },
+    format: {
+      type: "string",
+      description: "File format (cjs|esm)"
+    },
+    declaration: {
+      type: "boolean",
+      description: "Generate type declaration file",
+      default: false
+      // alias: ["d"],
+    },
+    ext: {
+      type: "string",
+      description: "File extension (mjs|js|ts)"
+      // valueHint: "mjs|js|ts",
+    },
+    jsx: {
+      type: "string",
+      description: "Specify which JSX runtime to use (transform|preserve|automatic)"
+    },
+    jsxFactory: {
+      type: "string",
+      description: "JSX factory (h|React.createElement)"
+    },
+    jsxFragment: {
+      type: "string",
+      description: "JSX fragment (Fragment|React.Fragment)"
+    },
+    loaders: {
+      type: "string",
+      description: "Loaders (js|vue|sass)"
+    },
+    minify: {
+      type: "boolean",
+      description: "Minify output files",
+      default: false
+    },
+    target: {
+      type: "string",
+      description: "Target environment (esbuild)"
+    },
+    dontBuildCopyInstead: {
+      type: "string",
+      description: "Don't build copy instead of (glob patterns, e.g. '**/*.json') (default: ['**/templates/**'])"
+    }
+  }),
+  async run({ args }) {
+    if (args.mkdistOnly) {
+      const { writtenFiles } = await mkdist({
+        rootDir: resolve(args.cwd || process.cwd(), args.dir),
+        srcDir: args.src,
+        distDir: args.dist,
+        cleanDist: args.clean,
+        format: args.format,
+        pattern: args.pattern,
+        ext: args.ext,
+        declaration: args.declaration,
+        loaders: args.loaders?.split(","),
+        esbuild: {
+          jsx: args.jsx,
+          jsxFactory: args.jsxFactory,
+          jsxFragment: args.jsxFragment,
+          minify: args.minify,
+          target: args.target
+        }
+      });
+      console.log(writtenFiles.map((f) => `- ${f}`).join("\n"));
+      process.exit(0);
+    }
+    await ensureDlerConfig(args.dev);
+    await dlerBuild(args.dev);
+  }
+});

package/bin/app/rempts/cmd.js

@@ -79,23 +79,17 @@ export default defineCommand({
       } else {
         cmdsRoot = path.resolve(cmdsRoot);
       }
-      relinka(
-        "info",
-        `\u{1F680} Creating ${cmdNames.length} command(s): ${cmdNames.join(", ")}`
-      );
+      relinka("info", `\u{1F680} Creating ${cmdNames.length} command(s): ${cmdNames.join(", ")}`);
       for (const cmdName of cmdNames) {
         const dirPath = path.join(cmdsRoot, cmdName);
         const filePath = path.join(dirPath, "cmd.ts");
         if (await fs.pathExists(filePath) && !args.overwrite) {
-          relinka(
-            "warn",
-            `Command "${cmdName}" already exists. Use --overwrite to overwrite.`
-          );
+          relinka("warn", `Command "${cmdName}" already exists. Use --overwrite to overwrite.`);
           continue;
         }
         await fs.ensureDir(dirPath);
         const content = generateCommandTemplate(cmdName);
-        await fs.writeFile(filePath, content, "utf-8");
+        await fs.writeFile(filePath, content, "utf8");
         relinka("log", `\u2705 Created new command: ${filePath}`);
       }
       if (cliFilePath) {
@@ -118,42 +112,30 @@ export default defineCommand({
         return;
       }
       if (await fs.pathExists(outPath2) && !args.overwrite) {
-        relinka(
-          "warn",
-          `\u274C File "${outPath2}" already exists. Use --overwrite to overwrite.`
-        );
+        relinka("warn", `\u274C File "${outPath2}" already exists. Use --overwrite to overwrite.`);
         return;
       }
       const exports2 = generateExports(cmdDirs2);
       await fs.ensureDir(path.dirname(outPath2));
-      await fs.writeFile(outPath2, exports2, "utf-8");
+      await fs.writeFile(outPath2, exports2, "utf8");
       relinka("success", `\u2705 Generated command exports at: ${outPath2}`);
-      relinka(
-        "log",
-        `Found ${cmdDirs2.length} command(s): ${cmdDirs2.join(", ")}`
-      );
+      relinka("log", `Found ${cmdDirs2.length} command(s): ${cmdDirs2.join(", ")}`);
       return;
     }
     const root = path.resolve("src/app");
     const outPath = path.resolve(args.outFile ?? "src/app/cmds.ts");
     if (await fs.pathExists(outPath) && !args.overwrite) {
-      relinka(
-        "warn",
-        `\u274C File "${outPath}" already exists. Use --overwrite to overwrite.`
-      );
+      relinka("warn", `\u274C File "${outPath}" already exists. Use --overwrite to overwrite.`);
       return;
     }
     const cmdDirs = (args.cmdDirs ?? []).length > 0 ? args.cmdDirs ?? [] : await findCommandDirs(root);
     if (cmdDirs.length === 0) {
-      relinka(
-        "warn",
-        "No command directories found with cmd.ts or cmd.js files."
-      );
+      relinka("warn", "No command directories found with cmd.ts or cmd.js files.");
       return;
     }
     const exports = generateExports(cmdDirs);
     await fs.ensureDir(path.dirname(outPath));
-    await fs.writeFile(outPath, exports, "utf-8");
+    await fs.writeFile(outPath, exports, "utf8");
     relinka("success", `\u2705 Generated command exports at: ${outPath}`);
     relinka("log", `Found ${cmdDirs.length} command(s): ${cmdDirs.join(", ")}`);
     if (didInit) {
@@ -197,12 +179,10 @@ async function handleDlerConfig() {
       const firstScript = Object.values(coreIsCLI.scripts)[0];
       const scriptPath = path.resolve(firstScript);
       if (await fs.pathExists(scriptPath)) {
-        const content = await fs.readFile(scriptPath, "utf-8");
+        const content = await fs.readFile(scriptPath, "utf8");
         if (content.includes("@reliverse/rempts")) {
           if (content.includes("runMain")) {
-            const cmdsRootMatch = content.match(
-              /cmdsRootPath:\s*["']([^"']+)["']/
-            );
+            const cmdsRootMatch = content.match(/cmdsRootPath:\s*["']([^"']+)["']/);
             if (cmdsRootMatch?.[1]) {
               cmdsRoot = path.resolve(cmdsRootMatch[1]);
             }
@@ -226,7 +206,7 @@ async function ensureCliFile(filePath) {
   const resolvedPath = path.resolve(filePath);
   if (!await fs.pathExists(resolvedPath)) {
     await fs.ensureDir(path.dirname(resolvedPath));
-    await fs.writeFile(resolvedPath, cliTemplate, "utf-8");
+    await fs.writeFile(resolvedPath, cliTemplate, "utf8");
     relinka("log", `\u2705 Created CLI entry file: ${resolvedPath}`);
     return resolvedPath;
   }
@@ -262,9 +242,7 @@ function generateExports(cmdDirs) {
     ""
   ];
   for (const dir of cmdDirs) {
-    const funcName = "get" + dir.split(/[/\\]/).map(
-      (part) => part.charAt(0).toUpperCase() + part.slice(1).replace(/[^a-zA-Z0-9]/g, "")
-    ).join("") + "Cmd";
+    const funcName = "get" + dir.split(/[/\\]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1).replace(/[^a-zA-Z0-9]/g, "")).join("") + "Cmd";
     lines.push(
       `export const ${funcName} = async (): Promise<Command> => loadCommand("${dir}");`,
       ""

package/bin/app/rename/cmd.js

@@ -24,7 +24,7 @@ function isCommonJSFile(content) {
 async function getAllFilesAsync(dir, baseDir = dir, recursive = true) {
   let fileList = [];
   const entries = await readdir(dir, {
-    encoding: "utf-8",
+    encoding: "utf8",
     withFileTypes: true
   });
   for (const entry of entries) {
@@ -45,10 +45,8 @@ async function prepareCLIFiles(revert = false, recursive = true, useDtsTxtForPre
   const configPath = ".config/dler.ts";
   let srcDir = "src";
   if (existsSync(configPath)) {
-    const configContent = readFileSync(configPath, "utf-8");
-    const configMatch = configContent.match(
-      /coreEntrySrcDir:\s*["']([^"']+)["']/
-    );
+    const configContent = readFileSync(configPath, "utf8");
+    const configMatch = configContent.match(/coreEntrySrcDir:\s*["']([^"']+)["']/);
     srcDir = configMatch?.[1] ?? srcDir;
   }
   if (!existsSync(srcDir)) {
@@ -99,7 +97,7 @@ async function prepareCLIFiles(revert = false, recursive = true, useDtsTxtForPre
         await safeRename(fullPath, newName);
         renamedCount++;
       } else if (fileName.endsWith(".js") && !fileName.endsWith(".cjs")) {
-        const content = readFileSync(fullPath, "utf-8");
+        const content = readFileSync(fullPath, "utf8");
         if (isCommonJSFile(content)) {
           const newName = join(dir, `${baseName}.cjs`);
           relinka("log", `Renaming ${fullPath} to ${newName}`);
@@ -109,10 +107,7 @@ async function prepareCLIFiles(revert = false, recursive = true, useDtsTxtForPre
       }
     }
   }
-  relinka(
-    "log",
-    `CLI file preparation completed. Renamed ${renamedCount} files.`
-  );
+  relinka("log", `CLI file preparation completed. Renamed ${renamedCount} files.`);
 }
 export default defineCommand({
   meta: {
@@ -162,11 +157,7 @@ export default defineCommand({
     } = args;
     if (prepareMyCLI === true) {
       try {
-        await prepareCLIFiles(
-          revert === true,
-          recursive,
-          useDtsTxtForPrepareMyCLI
-        );
+        await prepareCLIFiles(revert === true, recursive, useDtsTxtForPrepareMyCLI);
         relinka("log", "Successfully prepared CLI files");
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);

package/bin/app/spell/cmd.js

@@ -41,9 +41,7 @@ export default defineCommand({
     console.log("\nResults:");
     for (const result of results) {
       const status = result.success ? "\u2713" : "\u2717";
-      console.log(
-        `${status} ${result.file}: ${result.spell.type} - ${result.message}`
-      );
+      console.log(`${status} ${result.file}: ${result.spell.type} - ${result.message}`);
     }
   }
 });

package/bin/app/split/cmd.js

@@ -1,10 +1,6 @@
 import fs from "@reliverse/relifso";
 import { defineArgs, defineCommand } from "@reliverse/rempts";
-import {
-  getAllSourceFiles,
-  splitLargeFileByLines,
-  splitLargeFunctions
-} from "./impl.js";
+import { getAllSourceFiles, splitLargeFileByLines, splitLargeFunctions } from "./impl.js";
 export default defineCommand({
   args: defineArgs({
     directory: {

package/bin/app/split/impl.js

@@ -43,12 +43,7 @@ export function splitLargeFileByLines(filePath, threshold) {
 }
 export function splitLargeFunctions(filePath, funcLineThreshold) {
   const sourceCode = fs.readFileSync(filePath, "utf8");
-  const sourceFile = ts.createSourceFile(
-    filePath,
-    sourceCode,
-    ts.ScriptTarget.ESNext,
-    true
-  );
+  const sourceFile = ts.createSourceFile(filePath, sourceCode, ts.ScriptTarget.ESNext, true);
   let newSource = sourceCode;
   const getLineOfPosition = (pos) => {
     return sourceFile.getLineAndCharacterOfPosition(pos).line;