binary-collections 2.0.10 → 2.0.11

package/lib/del-node-modules.js

@@ -1,15 +1,211 @@
-const glob = require("glob");
-const { delStream } = require("./utils/index.cjs");
-const globalIgnore = [
-    // ignore .git .github folder
-    "**/.git*",
-    // ignore composer folder
-    "**/vendor/**"
-];
-console.log("cleaning node_modules in", process.cwd());
-const g3 = new glob.Glob("**/node_modules", {
-    withFileTypes: false,
-    cwd: process.cwd(),
-    ignore: globalIgnore
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const fs = require("fs");
+const fsp = fs.promises;
+const path = require("path");
+const os = require("os");
+const minimist = require("minimist");
+// ----------------------
+// CLI
+// ----------------------
+const argv = minimist(process.argv.slice(2), {
+    boolean: ["force", "help"],
+    alias: { h: "help", f: "force", c: "concurrent" },
+    default: { force: false, concurrent: 2 }
 });
-delStream(g3);
+if (argv.help) {
+    console.log(`Usage: clean-node [--force] [-c|--concurrent N]
+By default runs in dry-run mode. Use --force to actually delete.
+Use -c/--concurrent to set concurrent removals (default 2).`);
+    process.exit(0);
+}
+const DRY_RUN = !argv.force;
+const defaultConcurrency = Math.max(2, os.cpus().length || 2);
+const CONCURRENCY = Math.max(1, Number(argv.concurrent || argv.c || defaultConcurrency));
+// ----------------------
+// CONSTANTS
+// ----------------------
+const customChars = "@.";
+const vowels = "aeiouAEIOU";
+const alnum = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+const combined = alnum + vowels + customChars;
+const ROOT = process.cwd();
+// ----------------------
+// HELPERS
+// ----------------------
+function isSymlinkAsync(p) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            return (yield fsp.lstat(p)).isSymbolicLink();
+        }
+        catch (_a) {
+            return false;
+        }
+    });
+}
+function removeAsync(target) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (yield isSymlinkAsync(target)) {
+            console.log("Skipping symlink", target);
+            return;
+        }
+        if (DRY_RUN) {
+            console.log("Would remove", target);
+            return;
+        }
+        try {
+            yield fsp.rm(target, { recursive: true, force: true });
+            console.log("Deleting", target);
+        }
+        catch (e) {
+            console.error("Failed:", target, e.message);
+        }
+    });
+}
+function runWithConcurrency(tasks, concurrency) {
+    return new Promise((resolve, reject) => {
+        let i = 0;
+        let active = 0;
+        let done = 0;
+        const total = tasks.length;
+        if (total === 0)
+            return resolve();
+        function next() {
+            if (done === total)
+                return resolve();
+            while (active < concurrency && i < total) {
+                const idx = i++;
+                active++;
+                Promise.resolve()
+                    .then(() => tasks[idx]())
+                    .then(() => {
+                    active--;
+                    done++;
+                    next();
+                })
+                    .catch((err) => reject(err));
+            }
+        }
+        next();
+    });
+}
+// `removeAsync` is the single deletion path; synchronous removals were
+// removed in favor of collecting targets and executing them with
+// `runWithConcurrency` so all deletions respect `DRY_RUN` and concurrency.
+/**
+ * Walk (no symlink traversal)
+ */
+function walk(dir, callback, { skipNodeModulesChildren = false } = {}) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch (_a) {
+        return;
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        // 🚫 never follow symlinks
+        if (entry.isSymbolicLink())
+            continue;
+        // skip inside node_modules/*
+        if (skipNodeModulesChildren && dir.includes("node_modules"))
+            continue;
+        callback(fullPath, entry);
+        if (entry.isDirectory()) {
+            if (skipNodeModulesChildren && entry.name === "node_modules") {
+                continue;
+            }
+            walk(fullPath, callback, { skipNodeModulesChildren });
+        }
+    }
+}
+// ----------------------
+// NODE_MODULES HANDLER
+// ----------------------
+function processNodeModules(dir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log("Found:", dir);
+        let items;
+        try {
+            items = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch (_a) {
+            return;
+        }
+        // determine targets whose first char is in the allowed combined set
+        const targets = items.filter((entry) => entry.name.length && combined.includes(entry.name[0]));
+        const tasks = targets.map((entry) => () => __awaiter(this, void 0, void 0, function* () {
+            const name = entry.name;
+            const target = path.join(dir, name);
+            // 🚫 skip symlinks entirely (Dirent gives this cheaply)
+            if (entry.isSymbolicLink && entry.isSymbolicLink()) {
+                console.log("Skipping symlink", target);
+                return;
+            }
+            yield removeAsync(target);
+        }));
+        // run with limited concurrency
+        yield runWithConcurrency(tasks, CONCURRENCY);
+        yield removeAsync(dir);
+    });
+}
+// ----------------------
+// MAIN
+// ----------------------
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const nodeModulesDirs = [];
+        // find node_modules
+        walk(ROOT, (fullPath, entry) => {
+            if (entry.isDirectory() && entry.name === "node_modules") {
+                nodeModulesDirs.push(fullPath);
+            }
+        });
+        for (const dir of nodeModulesDirs) {
+            // process each node_modules directory, await to avoid too many parallel top-level ops
+            // (internals already limit concurrency)
+            yield processNodeModules(dir);
+        }
+        // collect package/yarn targets then remove them with concurrency
+        const packageLocks = [];
+        const yarnLocks = [];
+        const yarnCaches = [];
+        walk(ROOT, (fullPath, entry) => {
+            const base = path.basename(fullPath);
+            if (base === "package-lock.json")
+                packageLocks.push(fullPath);
+            if (base === "yarn.lock")
+                yarnLocks.push(fullPath);
+            if (entry.isDirectory() && fullPath.endsWith(path.join(".yarn", "cache")))
+                yarnCaches.push(fullPath);
+        }, { skipNodeModulesChildren: true });
+        if (DRY_RUN) {
+            console.log("Would remove package-lock.json files:");
+            for (const p of packageLocks)
+                console.log(p);
+            console.log("Would remove yarn.lock files:");
+            for (const p of yarnLocks)
+                console.log(p);
+            console.log("Would remove .yarn/cache directories:");
+            for (const p of yarnCaches)
+                console.log(p);
+        }
+        else {
+            const allTasks = [];
+            allTasks.push(...packageLocks.map((p) => () => __awaiter(this, void 0, void 0, function* () { return removeAsync(p); })));
+            allTasks.push(...yarnLocks.map((p) => () => __awaiter(this, void 0, void 0, function* () { return removeAsync(p); })));
+            allTasks.push(...yarnCaches.map((p) => () => __awaiter(this, void 0, void 0, function* () { return removeAsync(p); })));
+            yield runWithConcurrency(allTasks, CONCURRENCY);
+        }
+    });
+}
+main();

package/lib/del-node-modules.mjs

@@ -1,7 +1,4 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
-import {
-  require_utils
-} from "./chunk-V3N3JEUF.mjs";
 import {
   __require,
   init_esm_shims
@@ -9,18 +6,152 @@ import {
 
 // src/del-node-modules.js
 init_esm_shims();
-var glob = __require("glob");
-var { delStream } = require_utils();
-var globalIgnore = [
-  // ignore .git .github folder
-  "**/.git*",
-  // ignore composer folder
-  "**/vendor/**"
-];
-console.log("cleaning node_modules in", process.cwd());
-var g3 = new glob.Glob("**/node_modules", {
-  withFileTypes: false,
-  cwd: process.cwd(),
-  ignore: globalIgnore
+var fs = __require("fs");
+var fsp = fs.promises;
+var path = __require("path");
+var os = __require("os");
+var minimist = __require("minimist");
+var argv = minimist(process.argv.slice(2), {
+  boolean: ["force", "help"],
+  alias: { h: "help", f: "force", c: "concurrent" },
+  default: { force: false, concurrent: 2 }
 });
-delStream(g3);
+if (argv.help) {
+  console.log(`Usage: clean-node [--force] [-c|--concurrent N]
+By default runs in dry-run mode. Use --force to actually delete.
+Use -c/--concurrent to set concurrent removals (default 2).`);
+  process.exit(0);
+}
+var DRY_RUN = !argv.force;
+var defaultConcurrency = Math.max(2, os.cpus().length || 2);
+var CONCURRENCY = Math.max(1, Number(argv.concurrent || argv.c || defaultConcurrency));
+var customChars = "@.";
+var vowels = "aeiouAEIOU";
+var alnum = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+var combined = alnum + vowels + customChars;
+var ROOT = process.cwd();
+async function isSymlinkAsync(p) {
+  try {
+    return (await fsp.lstat(p)).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+async function removeAsync(target) {
+  if (await isSymlinkAsync(target)) {
+    console.log("Skipping symlink", target);
+    return;
+  }
+  if (DRY_RUN) {
+    console.log("Would remove", target);
+    return;
+  }
+  try {
+    await fsp.rm(target, { recursive: true, force: true });
+    console.log("Deleting", target);
+  } catch (e) {
+    console.error("Failed:", target, e.message);
+  }
+}
+function runWithConcurrency(tasks, concurrency) {
+  return new Promise((resolve, reject) => {
+    let i = 0;
+    let active = 0;
+    let done = 0;
+    const total = tasks.length;
+    if (total === 0) return resolve();
+    function next() {
+      if (done === total) return resolve();
+      while (active < concurrency && i < total) {
+        const idx = i++;
+        active++;
+        Promise.resolve().then(() => tasks[idx]()).then(() => {
+          active--;
+          done++;
+          next();
+        }).catch((err) => reject(err));
+      }
+    }
+    next();
+  });
+}
+function walk(dir, callback, { skipNodeModulesChildren = false } = {}) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isSymbolicLink()) continue;
+    if (skipNodeModulesChildren && dir.includes("node_modules")) continue;
+    callback(fullPath, entry);
+    if (entry.isDirectory()) {
+      if (skipNodeModulesChildren && entry.name === "node_modules") {
+        continue;
+      }
+      walk(fullPath, callback, { skipNodeModulesChildren });
+    }
+  }
+}
+async function processNodeModules(dir) {
+  console.log("Found:", dir);
+  let items;
+  try {
+    items = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  const targets = items.filter((entry) => entry.name.length && combined.includes(entry.name[0]));
+  const tasks = targets.map((entry) => async () => {
+    const name = entry.name;
+    const target = path.join(dir, name);
+    if (entry.isSymbolicLink && entry.isSymbolicLink()) {
+      console.log("Skipping symlink", target);
+      return;
+    }
+    await removeAsync(target);
+  });
+  await runWithConcurrency(tasks, CONCURRENCY);
+  await removeAsync(dir);
+}
+async function main() {
+  const nodeModulesDirs = [];
+  walk(ROOT, (fullPath, entry) => {
+    if (entry.isDirectory() && entry.name === "node_modules") {
+      nodeModulesDirs.push(fullPath);
+    }
+  });
+  for (const dir of nodeModulesDirs) {
+    await processNodeModules(dir);
+  }
+  const packageLocks = [];
+  const yarnLocks = [];
+  const yarnCaches = [];
+  walk(
+    ROOT,
+    (fullPath, entry) => {
+      const base = path.basename(fullPath);
+      if (base === "package-lock.json") packageLocks.push(fullPath);
+      if (base === "yarn.lock") yarnLocks.push(fullPath);
+      if (entry.isDirectory() && fullPath.endsWith(path.join(".yarn", "cache"))) yarnCaches.push(fullPath);
+    },
+    { skipNodeModulesChildren: true }
+  );
+  if (DRY_RUN) {
+    console.log("Would remove package-lock.json files:");
+    for (const p of packageLocks) console.log(p);
+    console.log("Would remove yarn.lock files:");
+    for (const p of yarnLocks) console.log(p);
+    console.log("Would remove .yarn/cache directories:");
+    for (const p of yarnCaches) console.log(p);
+  } else {
+    const allTasks = [];
+    allTasks.push(...packageLocks.map((p) => async () => removeAsync(p)));
+    allTasks.push(...yarnLocks.map((p) => async () => removeAsync(p)));
+    allTasks.push(...yarnCaches.map((p) => async () => removeAsync(p)));
+    await runWithConcurrency(allTasks, CONCURRENCY);
+  }
+}
+main();

package/lib/del-ps.cjs

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -97,31 +98,78 @@ var require_utils = __commonJS({
     }
     module2.exports.getArgs = getArgs2;
     function del(fullPath) {
-      if (fs.statSync(fullPath).isDirectory()) {
-        const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
-        for (let i = 0; i < subdir.length; i++) {
-          del(subdir[i]);
+      try {
+        if (!fs.existsSync(fullPath)) return;
+        const stat = fs.lstatSync(fullPath);
+        if (stat.isSymbolicLink()) {
+          try {
+            fs.unlinkSync(fullPath);
+            console.log("deleted symlink", fullPath);
+          } catch (e) {
+            console.log("failed delete symlink", fullPath, e && e.message);
+          }
+          return;
+        }
+        if (stat.isDirectory()) {
+          const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
+          for (let i = 0; i < subdir.length; i++) {
+            del(subdir[i]);
+          }
+          try {
+            fs.rmdirSync(fullPath);
+            console.log("deleted", fullPath);
+          } catch (e) {
+            try {
+              fs.rmSync(fullPath, { recursive: true, force: true, retryDelay: 7e3 });
+              console.log("deleted", fullPath);
+            } catch (ee) {
+              console.log("failed delete", fullPath, ee && ee.message);
+            }
+          }
+          return;
         }
-      } else {
         try {
-          fs.rmSync(fullPath, { recursive: true, force: true, retryDelay: 7e3 });
+          fs.unlinkSync(fullPath);
           console.log("deleted", fullPath);
-        } catch (_) {
-          console.log("failed delete", fullPath);
+        } catch (e) {
+          try {
+            fs.rmSync(fullPath, { recursive: true, force: true, retryDelay: 7e3 });
+            console.log("deleted", fullPath);
+          } catch (ee) {
+            console.log("failed delete", fullPath, ee && ee.message);
+          }
         }
+      } catch (err) {
+        console.log("failed delete", fullPath, err && err.message);
       }
     }
     module2.exports.del = del;
     function delStream(globStream) {
       globStream.stream().on("data", (result) => {
         const fullPath = path.resolve(process.cwd(), result);
-        if (fs.statSync(fullPath).isDirectory()) {
-          const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
-          for (let i = 0; i < subdir.length; i++) {
-            del(subdir[i]);
+        try {
+          if (fs.existsSync(fullPath)) {
+            const stat = fs.lstatSync(fullPath);
+            if (stat.isSymbolicLink()) {
+              try {
+                fs.unlinkSync(fullPath);
+                console.log("deleted symlink", fullPath);
+              } catch (e) {
+                console.log("failed delete symlink", fullPath, e && e.message);
+              }
+              return;
+            }
+            if (stat.isDirectory()) {
+              const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
+              for (let i = 0; i < subdir.length; i++) {
+                del(subdir[i]);
+              }
+            }
           }
+          del(fullPath);
+        } catch (err) {
+          console.log("failed processing", fullPath, err && err.message);
         }
-        del(fullPath);
       });
     }
     module2.exports.delStream = delStream;

package/lib/del-ps.js

@@ -1,3 +1,4 @@
+"use strict";
 const crossSpawn = require("cross-spawn");
 const ps = require("ps-node");
 const isWin = require("./ps/isWin.js").default;

package/lib/del-ps.mjs

@@ -5,7 +5,7 @@ import {
 } from "./chunk-6S4NXESK.mjs";
 import {
   require_utils
-} from "./chunk-V3N3JEUF.mjs";
+} from "./chunk-Z6JLYU2J.mjs";
 import {
   __require,
   __toCommonJS,

package/lib/del-yarn-caches.cjs

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -88,31 +89,78 @@ var require_utils = __commonJS({
     }
     module2.exports.getArgs = getArgs;
     function del(fullPath) {
-      if (fs.statSync(fullPath).isDirectory()) {
-        const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
-        for (let i = 0; i < subdir.length; i++) {
-          del(subdir[i]);
+      try {
+        if (!fs.existsSync(fullPath)) return;
+        const stat = fs.lstatSync(fullPath);
+        if (stat.isSymbolicLink()) {
+          try {
+            fs.unlinkSync(fullPath);
+            console.log("deleted symlink", fullPath);
+          } catch (e) {
+            console.log("failed delete symlink", fullPath, e && e.message);
+          }
+          return;
+        }
+        if (stat.isDirectory()) {
+          const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
+          for (let i = 0; i < subdir.length; i++) {
+            del(subdir[i]);
+          }
+          try {
+            fs.rmdirSync(fullPath);
+            console.log("deleted", fullPath);
+          } catch (e) {
+            try {
+              fs.rmSync(fullPath, { recursive: true, force: true, retryDelay: 7e3 });
+              console.log("deleted", fullPath);
+            } catch (ee) {
+              console.log("failed delete", fullPath, ee && ee.message);
+            }
+          }
+          return;
         }
-      } else {
         try {
-          fs.rmSync(fullPath, { recursive: true, force: true, retryDelay: 7e3 });
+          fs.unlinkSync(fullPath);
           console.log("deleted", fullPath);
-        } catch (_) {
-          console.log("failed delete", fullPath);
+        } catch (e) {
+          try {
+            fs.rmSync(fullPath, { recursive: true, force: true, retryDelay: 7e3 });
+            console.log("deleted", fullPath);
+          } catch (ee) {
+            console.log("failed delete", fullPath, ee && ee.message);
+          }
         }
+      } catch (err) {
+        console.log("failed delete", fullPath, err && err.message);
       }
     }
     module2.exports.del = del;
     function delStream2(globStream) {
       globStream.stream().on("data", (result) => {
         const fullPath = path.resolve(process.cwd(), result);
-        if (fs.statSync(fullPath).isDirectory()) {
-          const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
-          for (let i = 0; i < subdir.length; i++) {
-            del(subdir[i]);
+        try {
+          if (fs.existsSync(fullPath)) {
+            const stat = fs.lstatSync(fullPath);
+            if (stat.isSymbolicLink()) {
+              try {
+                fs.unlinkSync(fullPath);
+                console.log("deleted symlink", fullPath);
+              } catch (e) {
+                console.log("failed delete symlink", fullPath, e && e.message);
+              }
+              return;
+            }
+            if (stat.isDirectory()) {
+              const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
+              for (let i = 0; i < subdir.length; i++) {
+                del(subdir[i]);
+              }
+            }
           }
+          del(fullPath);
+        } catch (err) {
+          console.log("failed processing", fullPath, err && err.message);
         }
-        del(fullPath);
       });
     }
     module2.exports.delStream = delStream2;

package/lib/del-yarn-caches.mjs

@@ -1,7 +1,7 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
   require_utils
-} from "./chunk-V3N3JEUF.mjs";
+} from "./chunk-Z6JLYU2J.mjs";
 import {
   __toESM,
   init_esm_shims

package/lib/find-node-modules-cli.js

@@ -1,3 +1,4 @@
 #!/usr/bin/env node
+"use strict";
 const findNodeModules = require("./find-node-modules.cjs");
 findNodeModules(null, console.log);