binary-collections 2.0.9 → 2.0.11

package/lib/del-node-modules.cjs

@@ -1,156 +1,151 @@
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-
-// node_modules/tsup/assets/cjs_shims.js
-var init_cjs_shims = __esm({
-  "node_modules/tsup/assets/cjs_shims.js"() {
-  }
+#!/usr/bin/env node
+// src/del-node-modules.js
+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 }
 });
-
-// src/utils.js
-var require_utils = __commonJS({
-  "src/utils.js"(exports2, module2) {
-    init_cjs_shims();
-    var fs = require("fs");
-    var path = require("upath");
-    var argv = require("minimist")(process.argv.slice(2));
-    var { exec } = require("child_process");
-    var { URL: URL2 } = require("url");
-    var { promisify } = require("util");
-    var execAsync = promisify(exec);
-    async function parseGitRemotes() {
-      try {
-        const { stdout } = await execAsync("git remote -v");
-        const lines = stdout.split("\n");
-        const remotes = {};
-        lines.forEach((line) => {
-          const [name, url] = line.split("	");
-          if (name && url) {
-            const [repoUrl] = url.split(" ");
-            try {
-              const parsedUrl = new URL2(repoUrl);
-              const pathParts = parsedUrl.pathname.split("/").filter(Boolean);
-              if (parsedUrl.hostname === "github.com" && pathParts.length === 2) {
-                let repoPath = pathParts.join("/");
-                if (repoPath.endsWith(".git")) {
-                  repoPath = repoPath.slice(0, -4);
-                }
-                remotes[name] = repoPath;
-              }
-            } catch (e) {
-              console.error("URL Parsing Error:", e.message);
-            }
-          }
-        });
-        return remotes;
-      } catch (error) {
-        console.error("Error:", error.message);
-        return {};
-      }
-    }
-    module2.exports.parseGitRemotes = parseGitRemotes;
-    function joinPathPreserveDriveLetter(...segments) {
-      let fullPath = require("path").join(...segments);
-      if (/^[a-z]:\\/.test(fullPath)) {
-        fullPath = fullPath.charAt(0).toUpperCase() + fullPath.slice(1);
+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));
       }
-      return fullPath;
-    }
-    module2.exports.joinPathPreserveDriveLetter = joinPathPreserveDriveLetter;
-    function getArgs() {
-      return argv;
     }
-    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]);
-        }
-      } else {
-        try {
-          fs.rmSync(fullPath, { recursive: true, force: true, retryDelay: 7e3 });
-          console.log("deleted", fullPath);
-        } catch (_) {
-          console.log("failed delete", fullPath);
-        }
+    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 });
     }
-    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]);
-          }
-        }
-        del(fullPath);
-      });
+  }
+}
+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;
     }
-    module2.exports.delStream = delStream2;
-    function getFileTreeString(hashArray) {
-      const tree = {};
-      const hashMap = {};
-      for (const entry of hashArray) {
-        const [filePath, hash] = entry.split(" ");
-        hashMap[filePath] = hash;
-        const parts = filePath.split("/");
-        let current = tree;
-        for (let i = 0; i < parts.length; i++) {
-          const part = parts[i];
-          if (i === parts.length - 1) {
-            current[part] = null;
-          } else {
-            current[part] = current[part] || {};
-            current = current[part];
-          }
-        }
-      }
-      function printNode(node, prefix = "", parentPath = "") {
-        const keys = Object.keys(node).sort();
-        let lines = [];
-        keys.forEach((key, idx) => {
-          const isLast = idx === keys.length - 1;
-          const branch = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
-          const currentPath = parentPath ? parentPath + "/" + key : key;
-          if (node[key] === null) {
-            lines.push(prefix + branch + key + " [" + (hashMap[currentPath] || "") + "]");
-          } else {
-            lines.push(prefix + branch + key + "/");
-            lines = lines.concat(printNode(node[key], prefix + (isLast ? "    " : "\u2502   "), currentPath));
-          }
-        });
-        return lines;
-      }
-      return printNode(tree, "", "").join("\n");
+    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);
     }
-    module2.exports.getFileTreeString = getFileTreeString;
-    var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-    module2.exports.delay = delay;
+  });
+  for (const dir of nodeModulesDirs) {
+    await processNodeModules(dir);
   }
-});
-
-// src/del-node-modules.js
-init_cjs_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
-});
-delStream(g3);
+  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-node-modules.js

@@ -1,15 +1,211 @@
-const glob = require("glob");
-const { delStream } = require("./utils");
-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();