qleaner 1.0.11 → 1.0.12

package/bin/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 const { Command } = require("commander");
-const { getFiles, unUsedFiles } = require("../command");
-const Table = require('cli-table3')
+const { list, scan } = require("../controllers/list");
+
 
 async function loadChalk() {
   return (await import("chalk")).default;
@@ -31,13 +31,7 @@ async function loadChalk() {
     )
     .option("-t, --table", "Print the results in a table")
     .action(async (path, options) => {
-      const { tableImports, tableFiles } = await getFiles(path, options, chalk);
-      if(options.table){
-        console.log(chalk.yellow('***************** Imported Files *****************'));
-        console.log(tableImports.toString());
-        console.log(chalk.green('***************** List Files *****************'));
-        console.log(tableFiles.toString());
-      }
+      await list(chalk, path, options);
     });
 
   program
@@ -51,24 +45,24 @@ async function loadChalk() {
       "Scan but don't print the excluded files"
     )
     .option("-t, --table", "Print the results in a table")
+    .option("-d, --dry-run", "Show what would be deleted without actually deleting (skips prompt)")
     .action(async (path, options) => {
-      const unusedFiles = await unUsedFiles(path, options);
-      // console.clear()
-      if(options.table){
-        const table = new Table({
-            head: ['Unused Files'],
-            colWidths: [50]
-        })
-        unusedFiles.forEach(file => {
-            table.push([file])
-        })
-        console.log(table.toString())
-
-      }else {
-        unusedFiles.forEach((file) => {
-            console.log(chalk.red(file));
-          });
-      }
+      await scan(chalk, path, options);
     });
+
+  program
+  .command('qlean-image')
+  .description("Scan the project for unused images")
+  .argument("<path>", "The path to the directory to scan for unused images")
+  .option("-e, --exclude-dir <dir...>", "Exclude directories from the scan")
+  .option("-f, --exclude-file <file...>", "Exclude files from the scan")
+  .option(
+    "-F, --exclude-file-print <files...>",
+    "Scan but don't print the excluded files"
+  )
+  .option("-t, --table", "Print the results in a table")
+  .action(async (path, options) => {
+
+  });
   program.parse(process.argv);
 })();

package/command.js

@@ -1,25 +1,26 @@
 const fg = require("fast-glob");
 const fs = require("fs");
-const Table = require('cli-table3');
+const Table = require("cli-table3");
 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");
 
 async function getFiles(directory = "src", options, chalk) {
-    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}`);
-        });
-    }
-    const files = await fg(contentPaths);
+  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}`);
+    });
+  }
+
+  const files = await fg(contentPaths);
   const imports = [];
   for (const file of files) {
     const code = fs.readFileSync(file, "utf8");
@@ -30,13 +31,12 @@ async function getFiles(directory = "src", options, chalk) {
     traverse(ast, {
       ImportDeclaration: ({ node }) => {
         imports.push({
-            from: node.source.value,
-            file: file,
-            line: node.loc.start.line,
-            column: node.loc.start.column,
+          from: node.source.value,
+          file: file,
+          line: node.loc.start.line,
+          column: node.loc.start.column,
         });
       },
-
     });
     //   ExportNamedDeclaration: ({ node }) => {
     //     if (node.declaration.declarations && node.declaration.declarations[0].id && node.declaration.declarations[0].id.name) {
@@ -51,123 +51,166 @@ async function getFiles(directory = "src", options, chalk) {
     //   },
     // });
   }
-  
+
   if (options.table) {
     const tableImports = new Table({
-        head: ['File', 'Line', 'Column', 'Import'],
-        colWidths: [20, 10, 10, 20],
+      head: ["File", "Line", "Column", "Import"],
+      colWidths: [20, 10, 10, 20],
+    });
+
+    const tableFiles = new Table({
+      head: ["File"],
+      colWidths: [20],
+    });
+
+    if (options.listFiles) {
+      files.forEach((file) => {
+        tableFiles.push([file]);
       });
-    
-      const tableFiles = new Table({
-        head: ['File'],
-        colWidths: [20],
+    }
+    if (options.listImports) {
+      imports.forEach((importStatement) => {
+        tableImports.push([
+          importStatement.file,
+          importStatement.line,
+          importStatement.column,
+          importStatement.from,
+        ]);
       });
-    
-      if (options.listFiles) {
-        files.forEach((file) => {
-            tableFiles.push([file]);
-        })
-      }
-      if (options.listImports) {
-        imports.forEach((importStatement) => {
-          tableImports.push([importStatement.file, importStatement.line, importStatement.column, importStatement.from]);
-        })
-      }
-      return { tableImports, tableFiles };
-  }else{
+    }
+    return { tableImports, tableFiles };
+  } else {
     if (options.listFiles) {
-        console.log(chalk.green('***************** Files *****************'));
-        files.forEach((file) => {
-            console.log(chalk.green(file));
-        })
-      }
-      if (options.listImports) {
-        console.log(chalk.yellow('***************** Imports *****************'));
-        imports.forEach((importStatement) => {
-          console.log(chalk.yellow(`${importStatement.file}:${importStatement.line}:${importStatement.column}  ${importStatement.from}`));
-        })
-      }
+      console.log(chalk.green("***************** Files *****************"));
+      files.forEach((file) => {
+        console.log(chalk.green(file));
+      });
+    }
+    if (options.listImports) {
+      console.log(chalk.yellow("***************** Imports *****************"));
+      imports.forEach((importStatement) => {
+        console.log(
+          chalk.yellow(
+            `${importStatement.file}:${importStatement.line}:${importStatement.column}  ${importStatement.from}`
+          )
+        );
+      });
+    }
+    return { tableImports: imports, tableFiles: files };
   }
 }
 
-async function unUsedFiles(directory = "src", 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}`);
-        });
-    }
-    
-    const files = await fg(contentPaths);
-    const imports = [];
-    const unusedFiles = [];
-    for (const file of files) {
-      const code = fs.readFileSync(file, "utf8");
+async function unUsedFiles(chalk, directory = "src", options) {
+  console.time('unUsedFiles');
+  const resolver = createResolver(directory);
+  const cache = loadCache(process.cwd());
+  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}`);
+    });
+  }
+
+  const files = await fg(contentPaths);
+  const imports = [];
+  const unusedFiles = [];
+
+  // debug log
+  // let debugCount = 0;
+  // console.log('total files---', files.length);
+  for (const file of files) {
+    const code = fs.readFileSync(file, "utf8");
+    if(needsRebuild(file, code, cache)) {
       const ast = parser.parse(code, {
         sourceType: "module",
-        plugins: [
-          "jsx",
-          "typescript",
-        ],
+        plugins: ["jsx", "typescript"],
       });
-  
+      cache[file] = {
+        hash: getFileHash(code),
+        imports: [],
+        isImported: false,
+        lastModified: fs.statSync(file).mtime.getTime(),
+      };
       traverse(ast, {
         ImportDeclaration: ({ node }) => {
           imports.push({
-              from: node.source.value,
-              file: file,
-              line: node.loc.start.line,
-              column: node.loc.start.column,
+            from: node.source.value,
+            file: file,
+            line: node.loc.start.line,
+            column: node.loc.start.column,
+          });
+          cache[file].imports.push({
+            from: node.source.value,
+            file: file,
+            line: node.loc.start.line,
+            column: node.loc.start.column,
+            lastModified: fs.statSync(file).mtime.getTime(),
           });
         },
       });
+    }else {
+      // debugCount++;
+      // console.log('cache hit', debugCount);
     }
+  }
 
-    // console.log('imports', imports);
-    // console.log('files', files);
-    for (const file of files) {
-        let i = 0;
-        // console.log('Checking', file);
-        let isFound = false;
-        while (!isFound && i < imports.length) {
-            
-            if (compareFiles(file, imports[i].from)) {
-                isFound = true;
-                break;
-            }else if(i === imports.length - 1) {
-                if(options.excludeFilePrint && options.excludeFilePrint.length > 0) {
-                    if(!isExcludedFile(file, options.excludeFilePrint)){
-                        unusedFiles.push(file); 
-                    }
-                }else {
-                    unusedFiles.push(file);
-                }
-                break;
+  // console.log('imports', imports);
+  // console.log('files', files);
+  // debugCount = 0;
+  // console.log('total files', files.length);
+  for (const file of files) {
+    const code = fs.readFileSync(file, "utf8");
+    if(!cache[file].isImported || needsRebuild(file, code, cache)) {
+      let i = 0;
+      // console.log('Checking', file);
+      let isFound = false;
+      while (!isFound && i < imports.length) {
+        const importFilePath = await resolver(
+          chalk,
+          imports[i].file,
+          imports[i].from
+        );
+        // console.log(chalk.blue('importFilePath'), importFilePath);
+        if (compareFiles(path.resolve(file), importFilePath)) {
+          isFound = true;
+          cache[file].isImported = true;
+          break;
+        } else if (i === imports.length - 1) {
+          if (options.excludeFilePrint && options.excludeFilePrint.length > 0) {
+            if (!isExcludedFile(file, options.excludeFilePrint)) {
+              unusedFiles.push(file);
             }
-            i++;
+          } else {
+            unusedFiles.push(file);
+          }
+          break;
         }
+        i++;
+      }
+    }else {
+      // debugCount++;
+      // console.log('debug hit', debugCount);
     }
-    return unusedFiles;
+  }
+  console.timeEnd('unUsedFiles');
+  saveCache(process.cwd(), cache);
+  return unusedFiles;
 }
 
 function isExcludedFile(file, excludeFiles) {
-    return excludeFiles.some(exclude => file.includes(exclude));
+  return excludeFiles.some((exclude) => file.includes(exclude));
 }
 
-function compareFiles(filePath, importPath) {  
-    const importNoExt = importPath.replace(/\.[^/.]+$/, "");
-    const prefixImportPath = importNoExt.replace(/^(?:\.{1,2}\/|[@~]+\/)+/, "");
-    // console.log('importNoExt', importNoExt, '  prefixImportPath', prefixImportPath, '  filePath', filePath, '  ', filePath.includes(prefixImportPath));
-    
-    return  filePath.includes(prefixImportPath);
+function compareFiles(filePath, importPath) {
+  return filePath === importPath;
 }
 
 module.exports = {
   getFiles,
   unUsedFiles,
-};
+};

package/controllers/list.js

@@ -0,0 +1,60 @@
+const { getFiles, unUsedFiles } = require("../command");
+const Table = require('cli-table3');
+const askDeleteFiles = require("../utils/utils");
+
+
+async function list(chalk, path, options) {
+    const { tableImports, tableFiles } = await getFiles(path, options, chalk);
+    if(options.table){
+      console.log(chalk.yellow('***************** Imported Files *****************'));
+      console.log(tableImports.toString());
+      console.log(chalk.green('***************** List Files *****************'));
+      console.log(tableFiles.toString());
+    }
+}
+
+async function scan(chalk, path, options) {
+    const unusedFiles = await unUsedFiles(chalk,path, options);
+    // console.clear()
+    
+    if (options.dryRun) {
+      console.log(chalk.cyan('\n[DRY RUN MODE] No files will be deleted\n'));
+    }
+    
+    if(options.table){
+      const table = new Table({
+          head: options.dryRun ? ['Unused Files (Would Delete)'] : ['Unused Files'],
+          colWidths: [50]
+      })
+      unusedFiles.forEach(file => {
+          table.push([file])
+      })
+      console.log(table.toString())
+
+    }else {
+      unusedFiles.forEach((file) => {
+          console.log(chalk.red(file));
+        });
+    }
+    
+    if (options.dryRun && unusedFiles.length > 0) {
+      console.log(chalk.cyan(`\n[DRY RUN] Would delete ${unusedFiles.length} file(s)`));
+      console.log(chalk.cyan('Run without --dry-run to actually delete files\n'));
+    } else if (!options.dryRun && unusedFiles.length > 0) {
+      askDeleteFiles(unusedFiles);
+    }
+}
+
+async function image(chalk, path, options) {
+    const unusedImages = await unUsedImages(chalk,path, options);
+    if(options.table){
+      console.log(chalk.yellow('***************** Unused Images *****************'));
+      console.log(unusedImages.toString());
+    }
+}
+
+
+module.exports = {
+  list,
+  scan
+};

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "qleaner",
   "packageManager": "yarn@4.6.0",
-  "version": "1.0.11",
+  "version": "1.0.12",
   "main": "command.js",
   "bin": "./bin/cli.js",
   "scripts": {
-    "start": "node ./bin/cli.js"
+    "start": "node ./bin/cli.js",
+    "resolve": "node ./utils/resolver.js"
   },
   "devDependencies": {
     "@types/node": "^20.10.5",
@@ -17,6 +18,7 @@
     "chalk": "^5.6.2",
     "cli-table3": "^0.6.5",
     "commander": "^14.0.2",
+    "enhanced-resolve": "^5.18.3",
     "fast-glob": "^3.3.3",
     "prompts": "^2.4.2"
   }

package/unused-check-cache.json

@@ -0,0 +1,180 @@
+{
+  "src/hello.find.tsx": {
+    "hash": "13088ef1169a758d26b7fde99ca67d5a",
+    "imports": [
+      {
+        "from": "./demo/functions",
+        "file": "src/hello.find.tsx",
+        "line": 1,
+        "column": 0,
+        "lastModified": 1764776380790
+      },
+      {
+        "from": "~/demo/book/hidden",
+        "file": "src/hello.find.tsx",
+        "line": 2,
+        "column": 0,
+        "lastModified": 1764776380790
+      }
+    ],
+    "isImported": true,
+    "lastModified": 1764776380790
+  },
+  "src/jambo.tsx": {
+    "hash": "6b9a7f99ad2bd68e567368a35bc2831c",
+    "imports": [
+      {
+        "from": "./demo/functions",
+        "file": "src/jambo.tsx",
+        "line": 1,
+        "column": 0,
+        "lastModified": 1764776380792
+      },
+      {
+        "from": "hello.find",
+        "file": "src/jambo.tsx",
+        "line": 2,
+        "column": 0,
+        "lastModified": 1764776380792
+      }
+    ],
+    "isImported": true,
+    "lastModified": 1764776380792
+  },
+  "src/main.js": {
+    "hash": "961f4425237e1551bb8ec8a136f12a66",
+    "imports": [
+      {
+        "from": "jambo",
+        "file": "src/main.js",
+        "line": 1,
+        "column": 0,
+        "lastModified": 1764776380796
+      },
+      {
+        "from": "poa",
+        "file": "src/main.js",
+        "line": 2,
+        "column": 0,
+        "lastModified": 1764776380796
+      },
+      {
+        "from": "./style.css",
+        "file": "src/main.js",
+        "line": 3,
+        "column": 0,
+        "lastModified": 1764776380796
+      },
+      {
+        "from": "./demo/demo",
+        "file": "src/main.js",
+        "line": 4,
+        "column": 0,
+        "lastModified": 1764776380796
+      },
+      {
+        "from": "./jambo",
+        "file": "src/main.js",
+        "line": 5,
+        "column": 0,
+        "lastModified": 1764776380796
+      },
+      {
+        "from": "@/demo/book/hidden",
+        "file": "src/main.js",
+        "line": 6,
+        "column": 0,
+        "lastModified": 1764776380796
+      }
+    ],
+    "isImported": true,
+    "lastModified": 1764776380796
+  },
+  "src/poa.tsx": {
+    "hash": "09d1c8072d500780c9d6b223f5609cc5",
+    "imports": [
+      {
+        "from": "one.png",
+        "file": "src/poa.tsx",
+        "line": 1,
+        "column": 0,
+        "lastModified": 1764776380809
+      }
+    ],
+    "isImported": true,
+    "lastModified": 1764776380809
+  },
+  "src/demo/demo.tsx": {
+    "hash": "fe20d628c85aad8b491b3e45e6559ce4",
+    "imports": [
+      {
+        "from": "../hello.find",
+        "file": "src/demo/demo.tsx",
+        "line": 1,
+        "column": 0,
+        "lastModified": 1764828590237
+      },
+      {
+        "from": "../demo/book/hidden",
+        "file": "src/demo/demo.tsx",
+        "line": 2,
+        "column": 0,
+        "lastModified": 1764828590237
+      }
+    ],
+    "isImported": true,
+    "lastModified": 1764828590237
+  },
+  "src/demo/functions.js": {
+    "hash": "091a10616a5be2b7c7803a3f7513453e",
+    "imports": [],
+    "isImported": true,
+    "lastModified": 1764776380788
+  },
+  "src/demo/public.tsx": {
+    "hash": "d41d8cd98f00b204e9800998ecf8427e",
+    "imports": [],
+    "isImported": false,
+    "lastModified": 1764690373726
+  },
+  "src/shell/main.js": {
+    "hash": "d41d8cd98f00b204e9800998ecf8427e",
+    "imports": [],
+    "isImported": false,
+    "lastModified": 1764822800241
+  },
+  "src/demo/book/hidden.tsx": {
+    "hash": "6c3fb783f6f246ad67252489ba9367f4",
+    "imports": [
+      {
+        "from": "../../main",
+        "file": "src/demo/book/hidden.tsx",
+        "line": 1,
+        "column": 0,
+        "lastModified": 1764776380785
+      }
+    ],
+    "isImported": true,
+    "lastModified": 1764776380785
+  },
+  "src/demo/book/public.tsx": {
+    "hash": "d41d8cd98f00b204e9800998ecf8427e",
+    "imports": [],
+    "isImported": false,
+    "lastModified": 1764690329997
+  },
+  "src/layer/shell/shell.tsx": {
+    "hash": "659029bd48113a93f0ce44bc1e8005d3",
+    "imports": [
+      {
+        "from": "../../demo/book/hidden",
+        "file": "src/layer/shell/shell.tsx",
+        "line": 1,
+        "column": 0,
+        "lastModified": 1764776380795
+      }
+    ],
+    "isImported": false,
+    "lastModified": 1764776380795
+  }
+}

package/utils/cache.js

@@ -0,0 +1,38 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+
+function loadCache(rootPath) {
+    const file = path.join(rootPath, "unused-check-cache.json");
+    if(!fs.existsSync(file)) return {};
+
+    try {
+        return JSON.parse(fs.readFileSync(file, 'utf8'))
+    } catch{
+        return {};
+    }
+}
+
+function getFileHash(content) {
+    return crypto.createHash('md5').update(content).digest('hex');
+}
+
+
+function needsRebuild(file, content, cache) {
+    const hash = getFileHash(content);
+    return !cache[file] || cache[file].hash !== hash
+}
+
+
+function saveCache(rootPath, cache) {
+    const file = path.join(rootPath, "unused-check-cache.json");
+    fs.writeFileSync(file, JSON.stringify(cache, null, 2))
+}
+
+module.exports = {
+    loadCache,
+    getFileHash,
+    needsRebuild,
+    saveCache
+}

package/utils/resolver.js

@@ -0,0 +1,32 @@
+const path = require('path');
+const {create} = require('enhanced-resolve');
+
+
+function createResolver(directory) {
+const resolver = create({
+    extensions: [".js", ".jsx", ".ts", ".tsx"],
+    alias: {
+      "@": path.resolve(directory),
+      "~": path.resolve(directory)
+    },
+    mainFiles: ["index"],
+    // Where resolution begins
+    modules: [
+        path.resolve(directory)
+    ]
+  });
+
+  return function resolveImport(chalk,sourceFile, importPath) {
+    // console.log(chalk.yellow('sourceFile--resolver'), sourceFile, chalk.yellow('importPath--resolver'), importPath);
+    return new Promise((resolve, reject) => {
+      resolver(path.dirname(sourceFile), importPath, (err, result) => {
+        if (err) return resolve(null);
+        resolve(path.resolve(result));
+      });
+    });
+  }
+}
+
+module.exports = {
+  createResolver
+};

package/utils/utils.js

@@ -28,7 +28,6 @@ async function askDeleteFiles(files) {
             return await deleteFiles(response.toDelete);
         }
     }
-    return response && response.toDelete ? response.toDelete : [];
 }
 
 async function moveToTrash(files) {