qleaner 1.2.0 → 1.3.0

package/command.js

@@ -1,16 +1,20 @@
 const fg = require("fast-glob");
-const fs = require("fs");
-const parser = require("@babel/parser");
-const traverse = require("@babel/traverse").default;
 const path = require("path");
 const { createResolver } = require("./utils/resolver");
-const {
-  loadCache,
-  getFileHash,
-  needsRebuild,
-  saveCache,
-} = require("./utils/cache");
+const { loadCache, saveCache } = require("./utils/cache");
 const { isExcludedFile, createStepBar } = require("./utils/utils");
+const { buildContentPaths } = require("./utils/pathBuilder");
+const { hydrateGraph } = require("./utils/graphUtils");
+const {
+  scanFilesForImportsAndExports,
+  processImports,
+  processExports,
+} = require("./utils/fileProcessing");
+const {
+  compareAndRemoveOldImports,
+  compareAndRemoveOldReExports,
+  compareAndRemoveOldExports,
+} = require("./utils/graphComparison");
 
 // Initializes the cache by clearing it (if requested) and loading it from disk
 function initializeCache(spinner, options, code = true) {
@@ -39,199 +43,142 @@ function initializeCache(spinner, options, code = true) {
   };
 }
 
-// Builds an array of glob patterns for file discovery, including exclusion patterns
-function buildContentPaths(directory, options) {
-  const contentPaths = [`${directory}/**/*.{tsx,ts,js,jsx}`];
-  if (options.excludeDir && options.excludeDir.length > 0) {
-    options.excludeDir.forEach((dir) => {
-      contentPaths.push(`!${dir}/**`);
-    });
-  }
-  if (options.excludeFile && options.excludeFile.length > 0) {
-    options.excludeFile.forEach((file) => {
-      contentPaths.push(`!${directory}/**/${file}`);
-    });
-  }
-  if (options.excludeExtensions && options.excludeExtensions.length > 0) {
-    options.excludeExtensions.forEach((extension) => {
-      contentPaths.push(`!${directory}/**/*.${extension}`);
-    });
-  }
-  return contentPaths;
-}
-
-// Extracts import statements from files by parsing AST, only processes files that need rebuilding
+/**
+ * Extracts import statements from files by parsing AST, only processes files that need rebuilding
+ * Orchestrates the scanning, processing, and comparison of imports/exports
+ * @param {Array<string>} files - Array of file paths to process
+ * @param {Map} graph - The dependency graph
+ * @param {Function} resolver - Resolver function to resolve import/export paths
+ * @param {Object} chalk - Chalk instance for progress bars
+ * @returns {number} Number indicating changes (imports count or removed items count)
+ */
 async function extractImportsFromFiles(files, graph, resolver, chalk) {
-  const scanBar = createStepBar(
-    `1/${files.length}`,
-    files.length,
-    "Scanning files",
-    chalk,
+  // Step 1: Scan files and extract imports/exports from AST
+  const { imports, exports, oldPaths, oldExports, oldReExported } =
+    await scanFilesForImportsAndExports(files, graph, chalk);
+  // Step 2: Process imports and add them to the graph
+  await processImports(imports, graph, resolver, chalk);
+  //  console.dir(imports, { depth: null });
+  // Step 3: Process exports and add them to the graph
+  await processExports(exports, graph, resolver, chalk);
+  // console.dir(exports, { depth: null });
+
+  // Step 4: Compare old state with new state and remove unused items
+  // These operations are independent and can run in parallel
+  const [removedFilesCount, removedReExportedCount, removedExportsCount] =
+    await Promise.all([
+      compareAndRemoveOldImports(oldPaths, graph, chalk),
+      compareAndRemoveOldReExports(oldReExported, graph, chalk),
+      compareAndRemoveOldExports(oldExports, graph, chalk),
+    ]);
+
+  // Return the number of imports or the number of removed files
+  return (
+    imports.length ||
+    removedFilesCount ||
+    removedReExportedCount ||
+    removedExportsCount
   );
-  let packingBar = null;
-  const imports = [];
-  const oldPaths = new Map();
-  for (const file of files) {
-    await new Promise((resolve) => setTimeout(resolve, 50));
-    scanBar.increment();
-    const filePath = path.resolve(file);
-    const code = fs.readFileSync(filePath, "utf8");
-    const isNeedsRebuild = needsRebuild(filePath, code, graph);
-    if (isNeedsRebuild) {
-      const ast = parser.parse(code, {
-        sourceType: "module",
-        plugins: ["jsx", "typescript", "decorators-legacy"],
-      });
-      // check if file is already in graph
-      if (graph.has(filePath)) {
-        const oldFiles = new Set(graph.get(filePath).imports);
-        oldPaths.set(filePath, new Set(oldFiles));
-      }
-      // create file graph node if it doesn't exist
-      graph.set(filePath, {
-        file: filePath,
-        hash: getFileHash(code),
-        imports: new Set(),
-        importedBy: new Set(),
-        lastModified: fs.statSync(filePath).mtime.getTime(),
-        size: fs.statSync(filePath).size,
-      });
-      traverse(ast, {
-        ImportDeclaration: ({ node }) => {
-          imports.push({
-            file: filePath,
-            source: node.source.value,
-          });
-        },
-        CallExpression({ node }) {
-          if (node.callee.type === "Import") {
-            const arg = node.arguments[0];
+}
 
-            if (arg?.type === "StringLiteral") {
-              imports.push({
-                file: filePath,
-                source: arg.value,
-                type: "dynamic",
-              });
-            } else {
-              imports.push({
-                file: filePath,
-                source: null,
-                type: "dynamic-variable",
-              });
-            }
-          }
-        },
-      });
-    }
+// Checks if a single file is imported/used by comparing it against all import statements
+// If not found in any imports and not excluded, adds it to the unused files set
+async function checkFileUsage(file, parentGraph, options) {
+  // Cache the file node to avoid repeated graph lookups
+  const fileNode = parentGraph.graph.get(file);
+  if (!fileNode || fileNode.importedBy.size > 0) {
+    return;
   }
-  scanBar.stop();
 
-  if (imports.length > 0) {
-    packingBar = createStepBar(
-      `1/${imports.length}`,
-      imports.length,
-      "Packing imports",
-      chalk,
-    );
-  }
-  for (const info of imports) {
-    if (packingBar) {
-      await new Promise((resolve) => setTimeout(resolve, 20));
-      packingBar.increment();
-    }
-    const { importPath, isMightBeModule } = await resolver(
-      info.file,
-      info.source,
-    );
-    if (!isMightBeModule) {
-      graph.get(info.file).imports.add(importPath);
-      if (!graph.has(importPath)) {
-        graph.set(importPath, {
-          file: importPath,
-          size: fs.statSync(importPath).size,
-          hash: getFileHash(fs.readFileSync(importPath, "utf8")),
-          imports: new Set(),
-          importedBy: new Set(),
-          lastModified: fs.statSync(importPath).mtime.getTime(),
-        });
-      }
-      graph.get(importPath).importedBy.add(info.file);
-    } else {
-      graph.get(info.file).imports.add(importPath);
-      if (!graph.has(importPath)) {
-        graph.set(importPath, {
-          file: importPath,
-          size: 0,
-          hash: null,
-          imports: new Set(),
-          importedBy: new Set(),
-          lastModified: null,
-        });
-      }
-      graph.get(importPath).importedBy.add(info.file);
+  // Check if file should be excluded
+  if (options.excludeFilePrint && options.excludeFilePrint.length > 0) {
+    if (isExcludedFile(file, options.excludeFilePrint)) {
+      return;
     }
   }
-  if (packingBar) {
-    packingBar.stop();
+
+  // Check if the file has a component name imported from the shared file
+  // It should not be considered unused if components are used via re-exports
+  const isUsed = checkImportedComponentsUsage(file, parentGraph);
+  if (!isUsed) {
+    parentGraph.unusedFiles.add(fileNode);
   }
+}
 
-  let compareBar = null;
-  if (oldPaths.size > 0) {
-    compareBar = createStepBar(
-      `1/${oldPaths.size}`,
-      oldPaths.size,
-      "Comparing old paths with new paths",
-      chalk,
-    );
+function checkImportedComponentsUsage(file, parentGraph) {
+  // Cache the file node to avoid repeated graph lookups
+  const fileNode = parentGraph.graph.get(file);
+  if (!fileNode) {
+    return false;
   }
-  // count the number of removed files
-  let removedFilesCount = 0;
-  // compare old paths with new paths
-  // if some old paths are found missing in new paths, remove them from the graph
-  for (const [filePath, oldFiles] of oldPaths) {
-    if (compareBar) {
-      await new Promise((resolve) => setTimeout(resolve, 20));
-      compareBar.increment();
-    }
-    if (graph.has(filePath)) {
-      // Find files that were in oldFiles but are no longer in current imports
-      const removedFiles = new Set(
-        [...oldFiles].filter((x) => !graph.get(filePath).imports.has(x)),
-      );
-      if (removedFiles.size > 0) {
-        // remove the removed files from the graph
-        removedFiles.forEach((file) => {
-          if (graph.has(file)) {
-            graph.get(file).importedBy.delete(filePath);
-          }
-        });
-        removedFilesCount++;
-      }
-    }
+
+  // Early exit if file is not re-exported
+  const reExportedBy = fileNode.reExportedBy;
+  if (reExportedBy.size === 0) {
+    return false;
   }
-  if (compareBar) {
-    compareBar.stop();
+
+  // Cache exported components and check once upfront
+  const exportedComponents = fileNode.exports;
+  if (exportedComponents.size === 0) {
+    return false;
   }
-  // return the number of imports or the number of removed files
-  return imports.length || removedFilesCount;
+  return trackExportedComponents(reExportedBy, exportedComponents, parentGraph);
 }
 
-// Checks if a single file is imported/used by comparing it against all import statements
-// If not found in any imports and not excluded, adds it to the unused files set
-async function checkFileUsage(file, parentGraph, options) {
-  if (
-    parentGraph.graph.has(file) &&
-    parentGraph.graph.get(file).importedBy.size === 0
-  ) {
-    if (options.excludeFilePrint && options.excludeFilePrint.length > 0) {
-      if (!isExcludedFile(file, options.excludeFilePrint)) {
-        parentGraph.unusedFiles.add(parentGraph.graph.get(file));
+function trackExportedComponents(reExportedBy, exportedComponents, parentGraph) {
+    let isUsed = false;
+    const notUsed = false
+    // Loop through the re-exported files, check if there is a file that imports any of the components or *
+    for (const reExportingFile of reExportedBy) {
+      // Cache the re-exporting file node
+      const reExportingNode = parentGraph.graph.get(reExportingFile);
+      if (!reExportingNode) {
+        continue;
+      }
+  
+      const importedBy = reExportingNode.importedBy; // A.ts -> B.ts
+      // if (importedBy.size === 0) {
+      //   continue;
+      // }
+
+      // check reExportedBy if available
+      const reExportedByFiles = reExportingNode.reExportedBy;
+      if (reExportedByFiles.size > 0) {
+        isUsed = trackExportedComponents(reExportedByFiles, exportedComponents, parentGraph);
+      }
+      // Loop through the importing files, check if they import any of the components or *
+      for (const importingFile of importedBy) {
+        // Cache the importing file node
+        const importingNode = parentGraph.graph.get(importingFile);
+        if (!importingNode) {
+          continue;
+        }
+  
+        const imported = importingNode.imported; // B.ts -> A.ts -> B.ts
+        if (!imported || !imported.has(reExportingFile)) {
+          continue;
+        }
+  
+        const components = imported.get(reExportingFile); // B.ts -> A.ts -> B.ts [['ComponentD', 'D2'], ['ComponentC', 'ComponentC']]
+        if (!components || components.size === 0) {
+          continue;
+        }
+  
+        // Check if any imported component matches exported components or is a wildcard
+        for (const component of components) {
+          if (
+            exportedComponents.has(component[0]) ||
+            exportedComponents.has(component[1]) ||
+            component[0] === "*" ||
+            component[1] === "*"
+          ) {
+            return true;
+          }
+        }
       }
-    } else {
-      parentGraph.unusedFiles.add(parentGraph.graph.get(file));
     }
-  }
+    return notUsed || isUsed;
 }
 
 // Checks all files to determine which ones are unused by comparing against import statements
@@ -241,7 +188,7 @@ async function checkUnusedFiles(files, parentGraph, options, chalk) {
     `1/${files.length}`,
     files.length,
     "Checking unused files",
-    chalk,
+    chalk
   );
   for (const file of files) {
     await new Promise((resolve) => setTimeout(resolve, 50));
@@ -258,24 +205,13 @@ function finalizeCacheAndReturn(parentGraph, spinner, imageParentGraph) {
   return parentGraph.unusedFiles;
 }
 
-function hydrateGraph(graphData) {
-  const graph = new Map();
-  for (const [file, data] of Object.entries(graphData)) {
-    graph.set(file, {
-      ...data,
-      imports: new Set(data.imports),
-      importedBy: new Set(data.importedBy),
-    });
-  }
-  return graph;
-}
 // Main function that orchestrates the unused files detection process
 // Step 1: Discovers files, Step 2: Extracts imports, Step 3: Checks which files are unused
-async function unUsedFiles(ora, chalk, directory = "src", options) {
+async function unUsedFiles(ora, chalk, directory = "src", pathConfig = null, options) {
   // Start spinner
   const spinner = ora("Start Qleaner scan...").start();
 
-  const resolver = createResolver(directory);
+  const resolver = createResolver(directory, pathConfig);
   const { parentGraph, imageParentGraph } = initializeCache(spinner, options);
   const contentPaths = buildContentPaths(directory, options);
 
@@ -292,7 +228,7 @@ async function unUsedFiles(ora, chalk, directory = "src", options) {
     files,
     parentGraph.graph,
     resolver,
-    chalk,
+    chalk
   );
 
   spinner.succeed(`Checked ${files.length} files`);
@@ -312,5 +248,4 @@ async function unUsedFiles(ora, chalk, directory = "src", options) {
 module.exports = {
   unUsedFiles,
   initializeCache,
-  hydrateGraph,
 };