dependency-radar 0.5.0 → 0.6.0

package/dist/runners/npmOutdated.js

@@ -84,7 +84,20 @@ function buildOutdatedCommand(tool) {
         lockFiles: ["package-lock.json", "npm-shrinkwrap.json"],
     };
 }
-async function runPackageOutdated(projectPath, tempDir, tool) {
+/**
+ * Run the package manager's `outdated` command for a project, normalize the output, and optionally persist results to disk.
+ *
+ * Executes the appropriate `outdated` command for `npm`, `pnpm`, or `yarn` in the repository lockfile directory (if found) and normalizes the tool-specific output into a consistent map of package names to `{ current, latest, wanted }`.
+ *
+ * @param projectPath - Path to the project root where the command should be executed if no lockfile directory is found
+ * @param tempDir - Directory used to write the tool-specific output file when persistence is enabled
+ * @param tool - Package manager to run (`"npm" | "pnpm" | "yarn"`)
+ * @param options - Optional settings
+ * @param options.persistToDisk - When `false`, do not write any output file to `tempDir`; defaults to `true`
+ * @returns A ToolResult containing `data` with the normalized outdated mapping on success, or `error` on failure. When persistence is enabled the result includes `file` with the path to the written JSON file.
+ */
+async function runPackageOutdated(projectPath, tempDir, tool, options = {}) {
+    const persistToDisk = options.persistToDisk !== false;
     const targetFile = path_1.default.join(tempDir, `${tool}-outdated.json`);
     try {
         const { cmd, args, lockFiles } = buildOutdatedCommand(tool);
@@ -94,38 +107,46 @@ async function runPackageOutdated(projectPath, tempDir, tool) {
         const parsed = (0, utils_1.parseJsonOutput)(result.stdout);
         const normalized = normalizeOutdatedOutput(tool, parsed);
         if (normalized && typeof normalized === "object") {
-            await (0, utils_1.writeJsonFile)(targetFile, normalized);
-            return { ok: true, data: normalized, file: targetFile };
+            if (persistToDisk) {
+                await (0, utils_1.writeJsonFile)(targetFile, normalized);
+            }
+            return { ok: true, data: normalized, ...(persistToDisk ? { file: targetFile } : {}) };
         }
         if (tool === "yarn" && isYarnOutdatedUnsupported(result)) {
+            if (persistToDisk) {
+                await (0, utils_1.writeJsonFile)(targetFile, {
+                    stdout: result.stdout,
+                    stderr: result.stderr,
+                    code: result.code,
+                });
+            }
+            return {
+                ok: false,
+                error: 'Yarn outdated is not available in this Yarn release (common on Yarn Berry).',
+                ...(persistToDisk ? { file: targetFile } : {}),
+            };
+        }
+        if (persistToDisk) {
             await (0, utils_1.writeJsonFile)(targetFile, {
                 stdout: result.stdout,
                 stderr: result.stderr,
                 code: result.code,
             });
-            return {
-                ok: false,
-                error: 'Yarn outdated is not available in this Yarn release (common on Yarn Berry).',
-                file: targetFile,
-            };
         }
-        await (0, utils_1.writeJsonFile)(targetFile, {
-            stdout: result.stdout,
-            stderr: result.stderr,
-            code: result.code,
-        });
         return {
             ok: false,
             error: `Failed to parse ${tool} outdated output`,
-            file: targetFile,
+            ...(persistToDisk ? { file: targetFile } : {}),
         };
     }
     catch (err) {
-        await (0, utils_1.writeJsonFile)(targetFile, { error: String(err) });
+        if (persistToDisk) {
+            await (0, utils_1.writeJsonFile)(targetFile, { error: String(err) });
+        }
         return {
             ok: false,
             error: `${tool} outdated failed: ${String(err)}`,
-            file: targetFile,
+            ...(persistToDisk ? { file: targetFile } : {}),
         };
     }
 }

package/dist/utils.js

@@ -58,11 +58,46 @@ function getDependencyRadarVersion() {
 async function ensureDir(dir) {
     await promises_1.default.mkdir(dir, { recursive: true });
 }
+/**
+ * Write JSON data to a file, creating parent directories as needed.
+ *
+ * Attempts to write a pretty-printed JSON representation of `data` to `filePath`. If pretty-printing fails due to an "Invalid string length" RangeError, falls back to a compact JSON representation.
+ *
+ * @param filePath - The path of the file to write
+ * @param data - The value to serialize to JSON (typically JSON-serializable)
+ * @throws Rethrows errors from JSON serialization (except handled "Invalid string length" for pretty-printing) and filesystem write operations
+ */
 async function writeJsonFile(filePath, data) {
     await ensureDir(path_1.default.dirname(filePath));
-    const content = JSON.stringify(data, null, 2);
+    let content;
+    try {
+        content = JSON.stringify(data, null, 2);
+    }
+    catch (err) {
+        // Large lockfile-derived trees can overflow string length when pretty-printing.
+        if (!isInvalidStringLengthError(err))
+            throw err;
+        content = JSON.stringify(data);
+    }
     await promises_1.default.writeFile(filePath, content, 'utf8');
 }
+/**
+ * Determines whether a value is a RangeError whose message indicates an "Invalid string length".
+ *
+ * @param error - The value to inspect
+ * @returns `true` if `error` is a `RangeError` with a message matching "Invalid string length" (case-insensitive), `false` otherwise.
+ */
+function isInvalidStringLengthError(error) {
+    if (!(error instanceof RangeError))
+        return false;
+    return /Invalid string length/i.test(error.message || '');
+}
+/**
+ * Check whether a filesystem path exists and is accessible.
+ *
+ * @param target - The path to check
+ * @returns `true` if the path exists and is accessible, `false` otherwise
+ */
 async function pathExists(target) {
     try {
         await promises_1.default.access(target);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dependency-radar",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Local-first dependency analysis tool that generates a single HTML report showing risk, size, usage, and structure of your project's dependencies.",
   "main": "dist/index.js",
   "bin": {
@@ -60,12 +60,8 @@
     "terser": "^5.27.0",
     "ts-node": "^10.9.2",
     "typescript": "^5.4.3",
-    "vite": "^5.4.0",
-    "vitest": "^2.1.8"
+    "vite": "^7.3.1",
+    "vitest": "^4.0.18"
   },
-  "packageManager": "pnpm@9.5.0+sha512.140036830124618d624a2187b50d04289d5a087f326c9edfc0ccd733d76c4f52c3a313d4fc148794a2a9d81553016004e6742e8cf850670268a7387fc220c903",
-  "dependencies": {
-    "@yarnpkg/lockfile": "^1.1.0",
-    "yaml": "^2.8.2"
-  }
+  "packageManager": "npm@10.9.2"
 }