poof 3.0.0 → 3.1.0

package/dist/index.mjs

@@ -1583,10 +1583,13 @@ const concurrentMap = async (items, concurrency, callback) => {
   await Promise.all(pending);
 };
 
-const glob = async (root, globPattern, options) => {
+const glob = async (root, globPatterns, options) => {
   const includeDot = options?.dot ?? false;
-  const isMatch = picomatch(globPattern, { dot: includeDot });
-  const isRecursive = globPattern.includes("**");
+  const ignorePatterns = options?.ignore;
+  const isMatch = picomatch(globPatterns, { dot: includeDot });
+  const shouldPrune = ignorePatterns?.length ? picomatch(ignorePatterns, { dot: true }) : void 0;
+  const patterns = Array.isArray(globPatterns) ? globPatterns : [globPatterns];
+  const isRecursive = patterns.some((p) => p.includes("**"));
   const results = [];
   const rootPrefix = root.length + 1;
   const crawl = async (directory) => {
@@ -1595,6 +1598,9 @@ const glob = async (root, globPattern, options) => {
     for (const entry of entries) {
       const fullPath = `${directory}/${entry.name}`;
       const relativePath = fullPath.slice(rootPrefix);
+      if (shouldPrune?.(relativePath)) {
+        continue;
+      }
       if (isMatch(relativePath)) {
         results.push(fullPath);
         continue;
@@ -1632,10 +1638,14 @@ const validatePath = (target, cwd, dangerous) => {
     }
   }
 };
-const resolvePatterns = async (patterns, cwd, dangerous = false) => {
+const needsDotMode = (globPattern) => /^\.[^\\/.]|[{,]\.[^\\/.]/.test(globPattern);
+const resolvePatterns = async (patterns, options) => {
+  const { cwd, dangerous = false, ignore } = options;
   const files = [];
   const notFound = [];
-  await concurrentMap(patterns, GLOB_CONCURRENCY, async (pattern) => {
+  const groups = /* @__PURE__ */ new Map();
+  const explicitPaths = [];
+  for (const pattern of patterns) {
     const posixPattern = toPosix(pattern);
     const fullPattern = path.isAbsolute(pattern) ? posixPattern : path.posix.join(toPosix(cwd), posixPattern);
     const scanned = picomatch.scan(fullPattern);
@@ -1643,30 +1653,57 @@ const resolvePatterns = async (patterns, cwd, dangerous = false) => {
     const pathToValidate = scanned.isGlob ? scanned.base || cwd : fullPattern;
     validatePath(pathToValidate, cwd, dangerous);
     if (!scanned.isGlob) {
-      await fs.access(fullPattern).then(
-        () => {
-          debug$2(`explicit path exists: ${fullPattern}`);
-          files.push(fullPattern);
-        },
-        () => {
-          debug$2(`explicit path not found: ${pattern}`);
-          notFound.push(pattern);
-        }
-      );
-      return;
+      explicitPaths.push({
+        fullPath: fullPattern,
+        originalPattern: pattern
+      });
+      continue;
     }
     let root = scanned.base || toPosix(cwd);
     if (root.endsWith("/")) {
       root = root.slice(0, -1);
     }
-    const descendIntoDotDirectories = /^\.[^\\/.]|[{,]\.[^\\/.]/.test(scanned.glob);
-    const globStart = performance.now();
-    const matches = await glob(root, scanned.glob, { dot: descendIntoDotDirectories });
-    debug$2(`glob pattern=${pattern} files=${matches.length} time=${(performance.now() - globStart).toFixed(2)}ms`);
-    for (const match of matches) {
-      files.push(match);
+    const group = groups.get(root);
+    if (group) {
+      group.globs.push(scanned.glob);
+      group.needsDot = group.needsDot || needsDotMode(scanned.glob);
+    } else {
+      groups.set(root, {
+        globs: [scanned.glob],
+        needsDot: needsDotMode(scanned.glob)
+      });
     }
-  });
+  }
+  await Promise.all([
+    // Check explicit paths concurrently
+    concurrentMap(explicitPaths, GLOB_CONCURRENCY, async ({ fullPath, originalPattern }) => {
+      await fs.access(fullPath).then(
+        () => {
+          debug$2(`explicit path exists: ${fullPath}`);
+          files.push(fullPath);
+        },
+        () => {
+          debug$2(`explicit path not found: ${originalPattern}`);
+          notFound.push(originalPattern);
+        }
+      );
+    }),
+    // Walk globs concurrently (one walk per unique root)
+    concurrentMap([...groups.keys()], GLOB_CONCURRENCY, async (root) => {
+      const group = groups.get(root);
+      const globStart = performance.now();
+      const matches = await glob(root, group.globs, {
+        dot: group.needsDot,
+        ignore
+      });
+      debug$2(
+        `glob root=${root} patterns=${group.globs.length} matches=${matches.length} time=${(performance.now() - globStart).toFixed(2)}ms`
+      );
+      for (const match of matches) {
+        files.push(match);
+      }
+    })
+  ]);
   return {
     files,
     notFound
@@ -1680,7 +1717,9 @@ const startRmWorker = () => {
   const child = spawn(process.execPath, [rmWorkerPath], {
     detached: true,
     stdio: ["pipe", "ignore", "ignore"],
-    windowsHide: true
+    windowsHide: true,
+    cwd: "/"
+    // Don't hold reference to parent's cwd (allows directory deletion on Windows)
   });
   const stdin = child.stdin;
   child.unref();
@@ -1745,14 +1784,35 @@ const withRetry = async (operation, shouldRetry) => {
 
 const debug = createDebug("poof:rename");
 const RENAME_CONCURRENCY = 100;
+const filterNestedPaths = (paths) => {
+  if (paths.length === 0) {
+    return [];
+  }
+  const sorted = paths.slice().sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  const roots = [];
+  let lastAccepted;
+  for (const filePath of sorted) {
+    if (lastAccepted && filePath.startsWith(`${lastAccepted}/`)) {
+      continue;
+    }
+    roots.push(filePath);
+    lastAccepted = filePath;
+  }
+  return roots;
+};
 const poof = async (patterns, options) => {
   const patternArray = Array.isArray(patterns) ? patterns : [patterns];
   const cwd = options?.cwd ?? process.cwd();
   debug(`patterns: ${JSON.stringify(patternArray)}, cwd: ${cwd}`);
   const resolveStart = performance.now();
-  const { files, notFound } = await resolvePatterns(patternArray, cwd, options?.dangerous ?? false);
+  const { files, notFound } = await resolvePatterns(patternArray, {
+    cwd,
+    dangerous: options?.dangerous,
+    ignore: options?.ignore
+  });
   debug(`resolve files=${files.length} time=${(performance.now() - resolveStart).toFixed(2)}ms`);
-  const filesToDelete = files;
+  const filesToDelete = filterNestedPaths(files);
+  debug(`filtered ${files.length} -> ${filesToDelete.length} (removed ${files.length - filesToDelete.length} nested)`);
   const errors = notFound.map((pattern) => {
     const error = new Error(`Path not found: ${pattern}`);
     error.code = "ENOENT";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poof",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "description": "Fast, non-blocking rm -rf alternative. Deletes files instantly while cleanup runs in the background.",
   "keywords": [
     "rm",
@@ -11,6 +11,11 @@
     "cli"
   ],
   "license": "MIT",
+  "repository": "privatenumber/poof",
+  "author": {
+    "name": "Hiroki Osame",
+    "email": "hiroki.osame@gmail.com"
+  },
   "files": [
     "dist"
   ],