@reliverse/dler 1.7.83 → 1.7.85

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

@@ -68,6 +68,16 @@ declare const _default: import("@reliverse/rempts").Command<{
         type: "boolean";
         description: string;
     };
+    "root-only": {
+        type: "boolean";
+        description: string;
+    };
+    recursive: {
+        type: "boolean";
+        description: string;
+        alias: string;
+        default: true;
+    };
     "save-prefix": {
         type: "string";
         description: string;

package/bin/app/update/cmd.js

@@ -193,6 +193,44 @@ async function findWorkspacePackageJsons(cwd) {
   }
   return pkgJsonPaths;
 }
+async function isMonorepo(cwd) {
+  try {
+    const root = await readPackageJSON(cwd);
+    const ws = root.workspaces;
+    if (Array.isArray(ws) && ws.length > 0) {
+      return true;
+    }
+    if (ws && Array.isArray(ws.packages) && ws.packages.length > 0) {
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+async function findAllPackageJsons(cwd) {
+  const packageJsonFiles = await glob("**/package.json", {
+    cwd,
+    absolute: true,
+    ignore: [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/.git/**",
+      "**/coverage/**",
+      "**/.next/**",
+      "**/.nuxt/**",
+      "**/out/**"
+    ]
+  });
+  const existingFiles = [];
+  for (const file of packageJsonFiles) {
+    if (await fs.pathExists(file)) {
+      existingFiles.push(file);
+    }
+  }
+  return existingFiles;
+}
 async function fetchVersionFromRegistry(packageName) {
   const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`);
   if (!response.ok) {
@@ -656,7 +694,7 @@ async function handleGlobalUpdates(args) {
 export default defineCommand({
   meta: {
     name: "update",
-    description: "Update all dependencies and catalogs to their latest available versions"
+    description: "Update all dependencies and catalogs to their latest available versions (recursively finds all package.json files by default)"
   },
   args: defineArgs({
     name: {
@@ -726,7 +764,17 @@ export default defineCommand({
     },
     "all-workspaces": {
       type: "boolean",
-      description: "Update dependencies across all workspace packages"
+      description: "Update dependencies across all workspace packages (requires --no-recursive)"
+    },
+    "root-only": {
+      type: "boolean",
+      description: "Update only the root package.json (requires --no-recursive)"
+    },
+    recursive: {
+      type: "boolean",
+      description: "Recursively find and update ALL package.json files in current directory tree (default: true, use --no-recursive to disable)",
+      alias: "r",
+      default: true
     },
     "save-prefix": {
       type: "string",
@@ -756,6 +804,17 @@ export default defineCommand({
         );
         return process.exit(1);
       }
+      if (args["all-workspaces"] && args["root-only"]) {
+        relinka("error", "Cannot specify both --all-workspaces and --root-only flags");
+        return process.exit(1);
+      }
+      if (args.recursive && (args["all-workspaces"] || args["root-only"])) {
+        relinka(
+          "error",
+          "Cannot use --recursive with --all-workspaces or --root-only flags. Use --no-recursive to disable recursive mode."
+        );
+        return process.exit(1);
+      }
       if (args.global) {
         return await handleGlobalUpdates(args);
       }
@@ -890,12 +949,59 @@ export default defineCommand({
         args["save-prefix"]
       );
       let totalUpdated = rootUpdated;
-      if (args["all-workspaces"]) {
-        const workspacePkgJsons = await findWorkspacePackageJsons(process.cwd());
-        const workspaceUpdated = await updateWorkspacePackages(workspacePkgJsons, args, options);
-        totalUpdated += workspaceUpdated;
+      if (args.recursive) {
+        const allPackageJsons = await findAllPackageJsons(process.cwd());
+        const rootPackageJsonPath = path.resolve(process.cwd(), "package.json");
+        const otherPackageJsons = allPackageJsons.filter((p) => p !== rootPackageJsonPath);
+        if (otherPackageJsons.length > 0) {
+          relinka(
+            "info",
+            `Found ${otherPackageJsons.length} additional package.json files to update recursively`
+          );
+          const recursiveUpdated = await updateWorkspacePackages(otherPackageJsons, args, options);
+          totalUpdated += recursiveUpdated;
+        } else {
+          relinka("info", "No additional package.json files found for recursive update");
+        }
+      } else {
+        const isMonorepoProject = await isMonorepo(process.cwd());
+        const shouldUpdateWorkspaces = args["all-workspaces"] || !args["root-only"] && isMonorepoProject;
+        if (shouldUpdateWorkspaces) {
+          const workspacePkgJsons = await findWorkspacePackageJsons(process.cwd());
+          if (workspacePkgJsons.length > 0) {
+            const workspaceUpdated = await updateWorkspacePackages(
+              workspacePkgJsons,
+              args,
+              options
+            );
+            totalUpdated += workspaceUpdated;
+          } else if (args["all-workspaces"]) {
+            relinka("warn", "No workspace packages found but --all-workspaces flag was provided");
+          }
+        } else if (isMonorepoProject) {
+          relinka("info", "Skipping workspace packages due to --root-only flag");
+        }
+      }
+      if (args.recursive) {
+        const allPackageJsonCount = (await findAllPackageJsons(process.cwd())).length;
+        relinka(
+          "success",
+          `Updated ${totalUpdated} dependencies across ${allPackageJsonCount} package.json files (recursive)`
+        );
+      } else {
+        const isMonorepoProject = await isMonorepo(process.cwd());
+        const shouldUpdateWorkspaces = args["all-workspaces"] || !args["root-only"] && isMonorepoProject;
+        if (isMonorepoProject && shouldUpdateWorkspaces) {
+          relinka(
+            "success",
+            `Updated ${totalUpdated} dependencies across workspace (root + workspaces)`
+          );
+        } else if (isMonorepoProject) {
+          relinka("success", `Updated ${totalUpdated} dependencies in root package.json only`);
+        } else {
+          relinka("success", `Updated ${totalUpdated} dependencies`);
+        }
       }
-      relinka("success", `Updated ${totalUpdated} dependencies across workspace`);
       const packageManager = await detectPackageManager(process.cwd());
       if (!args["with-install"]) {
         const installCommand = packageManager?.command || "your package manager";

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

@@ -13,13 +13,13 @@ export async function mkdist(options = {}) {
   options.srcDir = resolve(options.rootDir, options.srcDir || "src");
   options.distDir = resolve(options.rootDir, options.distDir || "dist");
   if (options.cleanDist !== false) {
-    relinka("info", "Cleaning distribution directory...");
+    relinka("verbose", "Cleaning distribution directory...");
     await fsp.unlink(options.distDir).catch(() => {
     });
     await fsp.rm(options.distDir, { recursive: true, force: true });
     await fsp.mkdir(options.distDir, { recursive: true });
   }
-  relinka("info", "Scanning input files...");
+  relinka("verbose", "Scanning input files...");
   const filePaths = await glob(options.pattern || "**", {
     absolute: false,
     ignore: ["**/node_modules", "**/coverage", "**/.git"],
@@ -36,10 +36,10 @@ export async function mkdist(options = {}) {
       getContents: () => fsp.readFile(sourcePath, { encoding: "utf8" })
     };
   });
-  relinka("info", `Found ${files.length} files to process`);
+  relinka("verbose", `Found ${files.length} files to process`);
   options.typescript ||= {};
   if (options.typescript.compilerOptions) {
-    relinka("info", "Normalizing TypeScript compiler options...");
+    relinka("verbose", "Normalizing TypeScript compiler options...");
     options.typescript.compilerOptions = await normalizeCompilerOptions(
       options.typescript.compilerOptions
     );
@@ -57,9 +57,9 @@ export async function mkdist(options = {}) {
       allowNonTsExtensions: true
     }
   );
-  relinka("info", "Creating file loaders...");
+  relinka("verbose", "Creating file loaders...");
   const { loadFile } = createLoader(options);
-  relinka("info", "Processing files with loaders...");
+  relinka("verbose", "Processing files with loaders...");
   const outputs = [];
   let processedCount = 0;
   await Promise.all(
@@ -71,7 +71,7 @@ export async function mkdist(options = {}) {
       processedCount++;
     })
   );
-  relinka("info", "Normalizing output extensions...");
+  relinka("verbose", "Normalizing output extensions...");
   const pathConflicts = [];
   for (const output of outputs.filter((o) => o.extension)) {
     const renamed = basename(output.path, extname(output.path)) + output.extension;
@@ -88,7 +88,7 @@ export async function mkdist(options = {}) {
   }
   const dtsOutputs = outputs.filter((o) => o.declaration && !o.skip);
   if (dtsOutputs.length > 0) {
-    relinka("info", `Generating TypeScript declarations for ${dtsOutputs.length} files...`);
+    relinka("verbose", `Generating TypeScript declarations for ${dtsOutputs.length} files...`);
     const vfs = new Map(dtsOutputs.map((o) => [o.srcPath, o.contents || ""]));
     const declarations = /* @__PURE__ */ Object.create(null);
     for (const loader of [getVueDeclarations, getDeclarations]) {
@@ -104,7 +104,7 @@ export async function mkdist(options = {}) {
       dtsProcessed++;
     }
   }
-  relinka("info", "Resolving relative imports...");
+  relinka("verbose", "Resolving relative imports...");
   const outPaths = new Set(outputs.map((o) => o.path));
   const resolveId = (from, id = "", resolveExtensions) => {
     if (!id.startsWith(".")) {
@@ -137,7 +137,7 @@ export async function mkdist(options = {}) {
     );
   }
   const outputsToWrite = outputs.filter((o) => !o.skip);
-  relinka("info", `Writing ${outputsToWrite.length} output files...`);
+  relinka("verbose", `Writing ${outputsToWrite.length} output files...`);
   const writtenFiles = [];
   const errors = [];
   let writtenCount = 0;

package/bin/libs/sdk/sdk-impl/config/info.js

@@ -1,5 +1,5 @@
 import { endPrompt, startPrompt } from "@reliverse/rempts";
-const version = "1.7.83";
+const version = "1.7.85";
 export async function showStartPrompt(isDev) {
   await startPrompt({
     titleColor: "inverse",

package/package.json

@@ -52,7 +52,7 @@
   "license": "MIT",
   "name": "@reliverse/dler",
   "type": "module",
-  "version": "1.7.83",
+  "version": "1.7.85",
   "keywords": [
     "reliverse",
     "cli",