binary-collections 2.0.10 → 2.0.12

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,11 +1,12 @@
-const crossSpawn = require("cross-spawn");
-const ps = require("ps-node");
-const isWin = require("./ps/isWin.js").default;
-const { getArgs } = require("./utils/index.cjs");
+"use strict";
+const crossSpawn = require('cross-spawn');
+const ps = require('ps-node');
+const isWin = require('./ps/isWin.js').default;
+const { getArgs } = require('./utils/index.cjs');
 getArgs()._.forEach((command) => {
     ps.lookup({
         command,
-        psargs: "ux"
+        psargs: 'ux'
     }, function (err, resultList) {
         if (err) {
             throw new Error(err);
@@ -14,15 +15,15 @@ getArgs()._.forEach((command) => {
             if (process) {
                 // console.log('PID: %s, COMMAND: %s, ARGUMENTS: %s', process.pid, process.command, process.arguments);
                 if (!isWin) {
-                    crossSpawn.spawnAsync("kill", ["-9", process.pid]).catch((e) => console.log(`kill failed ${e.message}`));
+                    crossSpawn.spawnAsync('kill', ['-9', process.pid]).catch((e) => console.log(`kill failed ${e.message}`));
                     crossSpawn
-                        .spawnAsync("killall", ["-9", process.pid])
+                        .spawnAsync('killall', ['-9', process.pid])
                         .catch((e) => console.log(`killall failed ${e.message}`));
                 }
                 else {
                     // wmic process where "name like 'java.exe'" delete
                     crossSpawn
-                        .spawnAsync("wmic", ["process", "where", `"name like '${command}'" delete`])
+                        .spawnAsync('wmic', ['process', 'where', `"name like '${command}'" delete`])
                         .catch((e) => console.log(`wmic failed ${e.message}`));
                 }
             }

package/lib/del-ps.mjs

@@ -5,7 +5,7 @@ import {
 } from "./chunk-6S4NXESK.mjs";
 import {
   require_utils
-} from "./chunk-V3N3JEUF.mjs";
+} from "./chunk-5RTXZVCW.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.js

@@ -35,9 +35,9 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 const glob = __importStar(require("glob"));
 const index_cjs_1 = require("./utils/index.cjs");
-const g3 = new glob.Glob(["**/.yarn/cache*", "**/.yarn/*.gz"], {
+const g3 = new glob.Glob(['**/.yarn/cache*', '**/.yarn/*.gz'], {
     withFileTypes: false,
     cwd: process.cwd(),
-    ignore: ["**/.git*", "**/vendor/**"]
+    ignore: ['**/.git*', '**/vendor/**']
 });
 (0, index_cjs_1.delStream)(g3);

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-5RTXZVCW.mjs";
 import {
   __toESM,
   init_esm_shims

package/lib/file/copy-cli.cjs

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/file/copy-cli.mjs
+var import_minimist = __toESM(require("minimist"), 1);
+
+// src/file/copy.mjs
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+var import_upath = __toESM(require("upath"), 1);
+async function copy(src, dest) {
+  if (!await import_fs_extra.default.pathExists(src)) {
+    throw new Error(`Source file does not exist: ${src}`);
+  }
+  const srcStat = await import_fs_extra.default.stat(src);
+  let finalDest = dest;
+  if (srcStat.isFile()) {
+    const destExists = await import_fs_extra.default.pathExists(dest);
+    const destStat = destExists ? await import_fs_extra.default.stat(dest) : null;
+    if (destStat && destStat.isDirectory()) {
+      finalDest = import_upath.default.join(dest, import_upath.default.basename(src));
+    }
+  }
+  await import_fs_extra.default.ensureDir(import_upath.default.dirname(finalDest));
+  await import_fs_extra.default.copy(src, finalDest, { overwrite: true });
+}
+
+// src/file/copy-cli.mjs
+function showHelp(exitCode = 0) {
+  console.log(
+    `
+Usage:
+  copy <src> <dest>
+
+Options:
+  -h, --help     Show this help message
+
+Examples:
+  copy file.txt backup/file.txt
+  copy ./src ./dist
+`.trim()
+  );
+  process.exit(exitCode);
+}
+async function main() {
+  const args = (0, import_minimist.default)(process.argv.slice(2), {
+    boolean: ["help", "h"],
+    alias: {
+      h: "help"
+    }
+  });
+  if (args.help) {
+    showHelp(0);
+  }
+  const [src, dest] = args._;
+  if (!src || !dest) {
+    console.error("Error: missing required arguments.\n");
+    showHelp(1);
+  }
+  try {
+    await copy(src, dest);
+    console.log(`Copied ${src} to ${dest}`);
+  } catch (err) {
+    console.error(`Error copying file: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}
+function handleError(err) {
+  console.error(`Unexpected error: ${err instanceof Error ? err.message : String(err)}`);
+  process.exit(1);
+}
+main().catch(handleError);

package/lib/file/copy-cli.d.mts

@@ -0,0 +1 @@
+export {};

package/lib/file/copy-cli.mjs

@@ -0,0 +1,55 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  copy
+} from "../chunk-OGXVGBRI.mjs";
+import {
+  init_esm_shims
+} from "../chunk-QQ4A6DLD.mjs";
+
+// src/file/copy-cli.mjs
+init_esm_shims();
+import minimist from "minimist";
+function showHelp(exitCode = 0) {
+  console.log(
+    `
+Usage:
+  copy <src> <dest>
+
+Options:
+  -h, --help     Show this help message
+
+Examples:
+  copy file.txt backup/file.txt
+  copy ./src ./dist
+`.trim()
+  );
+  process.exit(exitCode);
+}
+async function main() {
+  const args = minimist(process.argv.slice(2), {
+    boolean: ["help", "h"],
+    alias: {
+      h: "help"
+    }
+  });
+  if (args.help) {
+    showHelp(0);
+  }
+  const [src, dest] = args._;
+  if (!src || !dest) {
+    console.error("Error: missing required arguments.\n");
+    showHelp(1);
+  }
+  try {
+    await copy(src, dest);
+    console.log(`Copied ${src} to ${dest}`);
+  } catch (err) {
+    console.error(`Error copying file: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}
+function handleError(err) {
+  console.error(`Unexpected error: ${err instanceof Error ? err.message : String(err)}`);
+  process.exit(1);
+}
+main().catch(handleError);

package/lib/file/copy.cjs

@@ -0,0 +1,56 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/file/copy.mjs
+var copy_exports = {};
+__export(copy_exports, {
+  copy: () => copy
+});
+module.exports = __toCommonJS(copy_exports);
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+var import_upath = __toESM(require("upath"), 1);
+async function copy(src, dest) {
+  if (!await import_fs_extra.default.pathExists(src)) {
+    throw new Error(`Source file does not exist: ${src}`);
+  }
+  const srcStat = await import_fs_extra.default.stat(src);
+  let finalDest = dest;
+  if (srcStat.isFile()) {
+    const destExists = await import_fs_extra.default.pathExists(dest);
+    const destStat = destExists ? await import_fs_extra.default.stat(dest) : null;
+    if (destStat && destStat.isDirectory()) {
+      finalDest = import_upath.default.join(dest, import_upath.default.basename(src));
+    }
+  }
+  await import_fs_extra.default.ensureDir(import_upath.default.dirname(finalDest));
+  await import_fs_extra.default.copy(src, finalDest, { overwrite: true });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  copy
+});

package/lib/file/copy.d.mts

@@ -0,0 +1 @@
+export function copy(src: any, dest: any): Promise<void>;

package/lib/file/copy.mjs

@@ -0,0 +1,8 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  copy
+} from "../chunk-OGXVGBRI.mjs";
+import "../chunk-QQ4A6DLD.mjs";
+export {
+  copy
+};