pruny 1.9.2 → 1.10.1

package/dist/index.js

@@ -7632,7 +7632,7 @@ var source_default = chalk;
 
 // src/index.ts
 import { rmSync } from "node:fs";
-import { dirname as dirname2, join as join8 } from "node:path";
+import { dirname as dirname3, join as join8 } from "node:path";
 
 // src/scanner.ts
 var import_fast_glob4 = __toESM(require_out4(), 1);
@@ -9249,6 +9249,13 @@ async function scanUnusedFiles(config) {
         } else if (imp.startsWith("@/") || imp.startsWith("~/")) {
           const aliasPath = imp.substring(2);
           resolvedFile = resolveImport(cwd, aliasPath, extensions, cwd) || resolveImport(join2(cwd, "src"), aliasPath, extensions, cwd) || resolveImport(join2(cwd, "app"), aliasPath, extensions, cwd);
+          if (!resolvedFile) {
+            const pathParts = currentFile.split(/[/\\]/);
+            if (pathParts.length >= 2 && (pathParts[0] === "apps" || pathParts[0] === "packages")) {
+              const projectRoot = join2(cwd, pathParts[0], pathParts[1]);
+              resolvedFile = resolveImport(projectRoot, aliasPath, extensions, cwd) || resolveImport(join2(projectRoot, "src"), aliasPath, extensions, cwd) || resolveImport(join2(projectRoot, "app"), aliasPath, extensions, cwd);
+            }
+          }
         }
         if (resolvedFile && allFilesSet.has(resolvedFile)) {
           usedFiles.add(resolvedFile);
@@ -9308,6 +9315,9 @@ function resolveImport(baseDir, impPath, extensions, rootDir) {
 var import_fast_glob3 = __toESM(require_out4(), 1);
 import { readFileSync as readFileSync3 } from "node:fs";
 import { join as join3 } from "node:path";
+import { Worker } from "node:worker_threads";
+import { fileURLToPath } from "node:url";
+import { dirname as dirname2 } from "node:path";
 var IGNORED_EXPORT_NAMES = new Set([
   "config",
   "generateMetadata",
@@ -9336,6 +9346,71 @@ var IGNORED_EXPORT_NAMES = new Set([
   "OPTIONS",
   "default"
 ]);
+async function processFilesInParallel(files, cwd, workerCount) {
+  const __filename2 = fileURLToPath(import.meta.url);
+  const __dirname2 = dirname2(__filename2);
+  const workerPath = join3(__dirname2, "workers/file-processor.js");
+  const chunkSize = Math.ceil(files.length / workerCount);
+  const chunks = [];
+  for (let i = 0;i < workerCount; i++) {
+    const start = i * chunkSize;
+    const end = Math.min(start + chunkSize, files.length);
+    if (start < files.length) {
+      chunks.push(files.slice(start, end));
+    }
+  }
+  const exportMap = new Map;
+  const contents = new Map;
+  const progressMap = new Map;
+  const workerPromises = chunks.map((chunk, chunkId) => {
+    return new Promise((resolve2, reject) => {
+      const worker = new Worker(workerPath, {
+        workerData: {
+          files: chunk,
+          cwd,
+          chunkId
+        }
+      });
+      worker.on("message", (msg) => {
+        if (msg.type === "progress") {
+          progressMap.set(msg.chunkId, {
+            processed: msg.processed,
+            total: msg.total
+          });
+          let totalProcessed = 0;
+          let totalFiles = 0;
+          for (const [, progress] of progressMap.entries()) {
+            totalProcessed += progress.processed;
+            totalFiles += progress.total;
+          }
+          const percent = Math.round(totalProcessed / totalFiles * 100);
+          process.stdout.write(`\r   Progress: ${totalProcessed}/${totalFiles} (${percent}%)...${" ".repeat(10)}`);
+        } else if (msg.type === "complete") {
+          const result = msg.result;
+          const workerExportMap = new Map(Object.entries(result.exports));
+          const workerContents = new Map(Object.entries(result.contents));
+          for (const [file, exports] of workerExportMap.entries()) {
+            exportMap.set(file, exports);
+          }
+          for (const [file, content] of workerContents.entries()) {
+            contents.set(file, content);
+          }
+          worker.terminate();
+          resolve2();
+        }
+      });
+      worker.on("error", reject);
+      worker.on("exit", (code) => {
+        if (code !== 0) {
+          reject(new Error(`Worker stopped with exit code ${code}`));
+        }
+      });
+    });
+  });
+  await Promise.all(workerPromises);
+  process.stdout.write("\r" + " ".repeat(60) + "\r");
+  return { exportMap, contents };
+}
 async function scanUnusedExports(config) {
   const cwd = config.dir;
   const extensions = config.extensions;
@@ -9352,46 +9427,60 @@ async function scanUnusedExports(config) {
   let allExportsCount = 0;
   const inlineExportRegex = /^export\s+(?:async\s+)?(?:const|let|var|function|type|interface|enum|class)\s+([a-zA-Z0-9_$]+)/gm;
   const blockExportRegex = /^export\s*\{([^}]+)\}/gm;
-  console.log(`\uD83D\uDCDD Scanning ${allFiles.length} files for exports...`);
-  let processedFiles = 0;
-  for (const file of allFiles) {
-    try {
-      processedFiles++;
-      if (processedFiles % 10 === 0 || processedFiles === allFiles.length) {
-        const percent = Math.round(processedFiles / allFiles.length * 100);
-        const shortFile = file.length > 50 ? "..." + file.slice(-47) : file;
-        process.stdout.write(`\r   Progress: ${processedFiles}/${allFiles.length} (${percent}%) - ${shortFile}${" ".repeat(10)}`);
-      }
-      const content = readFileSync3(join3(cwd, file), "utf-8");
+  const USE_WORKERS = allFiles.length >= 500;
+  const WORKER_COUNT = 2;
+  if (USE_WORKERS) {
+    console.log(`\uD83D\uDCDD Scanning ${allFiles.length} files for exports (using ${WORKER_COUNT} workers)...`);
+    const result = await processFilesInParallel(allFiles, cwd, WORKER_COUNT);
+    for (const [file, exports] of result.exportMap.entries()) {
+      exportMap.set(file, exports);
+      allExportsCount += exports.length;
+    }
+    for (const [file, content] of result.contents.entries()) {
       totalContents.set(file, content);
-      const lines = content.split(`
+    }
+  } else {
+    console.log(`\uD83D\uDCDD Scanning ${allFiles.length} files for exports...`);
+    let processedFiles = 0;
+    for (const file of allFiles) {
+      try {
+        processedFiles++;
+        if (processedFiles % 10 === 0 || processedFiles === allFiles.length) {
+          const percent = Math.round(processedFiles / allFiles.length * 100);
+          const shortFile = file.length > 50 ? "..." + file.slice(-47) : file;
+          process.stdout.write(`\r   Progress: ${processedFiles}/${allFiles.length} (${percent}%) - ${shortFile}${" ".repeat(10)}`);
+        }
+        const content = readFileSync3(join3(cwd, file), "utf-8");
+        totalContents.set(file, content);
+        const lines = content.split(`
 `);
-      for (let i = 0;i < lines.length; i++) {
-        const line = lines[i];
-        inlineExportRegex.lastIndex = 0;
-        let match2;
-        while ((match2 = inlineExportRegex.exec(line)) !== null) {
-          if (addExport(file, match2[1], i + 1)) {
-            allExportsCount++;
-          }
-        }
-        blockExportRegex.lastIndex = 0;
-        while ((match2 = blockExportRegex.exec(line)) !== null) {
-          const names = match2[1].split(",").map((n) => {
-            const parts = n.trim().split(/\s+as\s+/);
-            return parts[parts.length - 1];
-          });
-          for (const name of names) {
-            if (addExport(file, name, i + 1)) {
+        for (let i = 0;i < lines.length; i++) {
+          const line = lines[i];
+          inlineExportRegex.lastIndex = 0;
+          let match2;
+          while ((match2 = inlineExportRegex.exec(line)) !== null) {
+            if (addExport(file, match2[1], i + 1)) {
               allExportsCount++;
             }
           }
+          blockExportRegex.lastIndex = 0;
+          while ((match2 = blockExportRegex.exec(line)) !== null) {
+            const names = match2[1].split(",").map((n) => {
+              const parts = n.trim().split(/\s+as\s+/);
+              return parts[parts.length - 1];
+            });
+            for (const name of names) {
+              if (addExport(file, name, i + 1)) {
+                allExportsCount++;
+              }
+            }
+          }
         }
-      }
-    } catch {}
-  }
-  if (processedFiles > 0) {
-    process.stdout.write("\r" + " ".repeat(60) + "\r");
+      } catch {}
+    }
+    if (processedFiles > 0) {
+      process.stdout.write("\r" + " ".repeat(60) + "\r");
+    }
   }
   function addExport(file, name, line) {
     if (name && !IGNORED_EXPORT_NAMES.has(name)) {
@@ -9412,17 +9501,34 @@ async function scanUnusedExports(config) {
       if (fileContent) {
         const lines = fileContent.split(`
 `);
+        let fileInMultilineComment = false;
+        let fileInTemplateLiteral = false;
         for (let i = 0;i < lines.length; i++) {
           if (i === exp.line - 1)
             continue;
           const line = lines[i];
           const trimmed = line.trim();
-          if (trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*"))
+          if (trimmed.includes("/*"))
+            fileInMultilineComment = true;
+          if (trimmed.includes("*/")) {
+            fileInMultilineComment = false;
+            continue;
+          }
+          if (fileInMultilineComment)
+            continue;
+          const backtickCount = (line.match(/`/g) || []).length;
+          if (backtickCount % 2 !== 0) {
+            fileInTemplateLiteral = !fileInTemplateLiteral;
+          }
+          if (fileInTemplateLiteral)
             continue;
+          if (trimmed.startsWith("//"))
+            continue;
+          const lineWithoutStrings = line.replace(/'[^']*'/g, "''").replace(/"[^"]*"/g, '""');
           const referenceRegex = new RegExp(`\\b${exp.name}\\b`);
-          if (referenceRegex.test(line)) {
-            const codePattern = new RegExp(`\\b${exp.name}\\s*[({.,;)]|\\b${exp.name}\\s*\\)|\\s+${exp.name}\\b`);
-            if (codePattern.test(line)) {
+          if (referenceRegex.test(lineWithoutStrings)) {
+            const codePattern = new RegExp(`\\b${exp.name}\\s*[({.,;<>|&)]|\\b${exp.name}\\s*\\)|\\s+${exp.name}\\b`);
+            if (codePattern.test(lineWithoutStrings)) {
               usedInternally = true;
               break;
             }
@@ -9448,7 +9554,8 @@ async function scanUnusedExports(config) {
 `);
           let inMultilineComment = false;
           let inTemplateLiteral = false;
-          for (const line of lines) {
+          for (let lineIndex = 0;lineIndex < lines.length; lineIndex++) {
+            const line = lines[lineIndex];
             const trimmed = line.trim();
             if (trimmed.includes("/*"))
               inMultilineComment = true;
@@ -9466,11 +9573,11 @@ async function scanUnusedExports(config) {
               continue;
             if (trimmed.startsWith("//"))
               continue;
-            if (trimmed.includes("{/*") || trimmed.includes("*/}"))
-              continue;
-            if (wordBoundaryPattern.test(line)) {
-              const codePattern = new RegExp(`\\b${exp.name}\\s*[({.,;)]|\\b${exp.name}\\s*\\)|\\s+${exp.name}\\b`);
-              if (codePattern.test(line)) {
+            const lineWithoutStrings = line.replace(/'[^']*'/g, "''").replace(/"[^"]*"/g, '""');
+            if (wordBoundaryPattern.test(lineWithoutStrings)) {
+              const codePattern = new RegExp(`\\b${exp.name}\\s*[({.,;<>|&)]|\\b${exp.name}\\s*\\)|\\s+${exp.name}\\b`);
+              const isMatch = codePattern.test(lineWithoutStrings);
+              if (isMatch) {
                 isUsed = true;
                 break;
               }
@@ -10159,7 +10266,7 @@ program2.action(async (options) => {
         console.log(source_default.yellow.bold(`\uD83D\uDDD1️  Deleting unused routes...
 `));
         for (const route of unusedRoutes) {
-          const routeDir = dirname2(join8(config.dir, route.filePath));
+          const routeDir = dirname3(join8(config.dir, route.filePath));
           try {
             rmSync(routeDir, { recursive: true, force: true });
             console.log(source_default.red(`   Deleted: ${route.filePath}`));

package/dist/workers/file-processor.js

@@ -0,0 +1,93 @@
+// src/workers/file-processor.ts
+import { parentPort, workerData } from "node:worker_threads";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+var IGNORED_EXPORT_NAMES = new Set([
+  "metadata",
+  "viewport",
+  "generateMetadata",
+  "generateViewport",
+  "generateStaticParams",
+  "generateImageMetadata",
+  "generateSitemaps",
+  "dynamic",
+  "dynamicParams",
+  "revalidate",
+  "fetchCache",
+  "runtime",
+  "preferredRegion",
+  "maxDuration",
+  "config",
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS",
+  "default"
+]);
+var inlineExportRegex = /^export\s+(?:async\s+)?(?:const|let|var|function|type|interface|enum|class)\s+([a-zA-Z0-9_$]+)/gm;
+var blockExportRegex = /^export\s*\{([^}]+)\}/gm;
+if (parentPort && workerData) {
+  const { files, cwd, chunkId } = workerData;
+  const exportMap = new Map;
+  const contents = new Map;
+  let processedCount = 0;
+  for (const file of files) {
+    try {
+      const content = readFileSync(join(cwd, file), "utf-8");
+      contents.set(file, content);
+      const lines = content.split(`
+`);
+      for (let i = 0;i < lines.length; i++) {
+        const line = lines[i];
+        inlineExportRegex.lastIndex = 0;
+        let match;
+        while ((match = inlineExportRegex.exec(line)) !== null) {
+          const name = match[1];
+          if (name && !IGNORED_EXPORT_NAMES.has(name)) {
+            if (!exportMap.has(file))
+              exportMap.set(file, []);
+            exportMap.get(file).push({ name, line: i + 1, file });
+          }
+        }
+        blockExportRegex.lastIndex = 0;
+        while ((match = blockExportRegex.exec(line)) !== null) {
+          const names = match[1].split(",").map((n) => {
+            const parts = n.trim().split(/\s+as\s+/);
+            return parts[parts.length - 1];
+          });
+          for (const name of names) {
+            if (name && !IGNORED_EXPORT_NAMES.has(name)) {
+              if (!exportMap.has(file))
+                exportMap.set(file, []);
+              exportMap.get(file).push({ name, line: i + 1, file });
+            }
+          }
+        }
+      }
+      processedCount++;
+      if (processedCount % 10 === 0) {
+        parentPort.postMessage({
+          type: "progress",
+          chunkId,
+          processed: processedCount,
+          total: files.length
+        });
+      }
+    } catch {
+      processedCount++;
+    }
+  }
+  const result = {
+    chunkId,
+    exports: Object.fromEntries(exportMap),
+    contents: Object.fromEntries(contents),
+    processedCount
+  };
+  parentPort.postMessage({
+    type: "complete",
+    result
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pruny",
-  "version": "1.9.2",
+  "version": "1.10.1",
   "description": "Find and remove unused Next.js API routes & Nest.js Controllers",
   "type": "module",
   "files": [
@@ -14,7 +14,7 @@
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "scripts": {
-    "build": "bun build ./src/index.ts --outdir ./dist --target node",
+    "build": "bun build ./src/index.ts --outdir ./dist --target node && mkdir -p dist/workers && bun build ./src/workers/file-processor.ts --outdir ./dist/workers --target node",
     "dev": "bun run ./src/index.ts",
     "lint": "eslint src/**",
     "audit": "bun run build && node dist/index.js",