binary-collections 2.0.6 → 2.0.8

package/lib/git-purge.mjs

@@ -1,20 +1,15 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
-import {
-  require_dist
-} from "./chunk-S4SJ7SDW.mjs";
 import {
   require_utils
-} from "./chunk-LPLPQBYP.mjs";
+} from "./chunk-APBWENF6.mjs";
 import {
+  __require,
   init_esm_shims
-} from "./chunk-7MSZ52XC.mjs";
-import {
-  __require
-} from "./chunk-AVDT32AY.mjs";
+} from "./chunk-AASHBCRW.mjs";
 
 // src/git-purge.js
 init_esm_shims();
-var { spawnAsync } = require_dist();
+var { spawnAsync } = __require("cross-spawn");
 var glob = __require("glob");
 var path = __require("path");
 var { delay } = require_utils();

package/lib/index.cjs

@@ -1,2 +1,100 @@
+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 __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;
+};
+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);
+
+// node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "node_modules/tsup/assets/cjs_shims.js"() {
+  }
+});
+
+// src/find-node-modules.js
+var require_find_node_modules = __commonJS({
+  "src/find-node-modules.js"(exports2, module2) {
+    init_cjs_shims();
+    var glob = require("glob");
+    var path = require("path");
+    function findNodeModules2(dir = process.cwd(), callback = null) {
+      const finalDir = typeof dir === "string" ? dir : process.cwd();
+      return new Promise((resolve, reject) => {
+        const results = [];
+        const g3 = new glob.Glob("**/node_modules", {
+          withFileTypes: false,
+          cwd: finalDir,
+          ignore: ["**/.git*", "**/vendor/**"]
+        });
+        const stream = g3.stream();
+        stream.on("data", (result) => {
+          const fullPath = path.resolve(finalDir, result);
+          if (typeof callback === "function") {
+            try {
+              callback(fullPath);
+            } catch (err) {
+              console.error("findNodeModules callback error:", err);
+            }
+          }
+          results.push(fullPath);
+        });
+        stream.on("error", (err) => reject(err));
+        stream.on("end", () => {
+          if (results.length === 0) {
+            console.log("No node_modules directories found.");
+          }
+          resolve(results);
+        });
+      });
+    }
+    if (typeof module2 !== "undefined" && require.main === module2) {
+      findNodeModules2(null, console.log).then((dirs) => {
+        console.log(`Found ${dirs.length} node_modules directories.`);
+      }).catch((err) => {
+        console.error("Error finding node_modules directories:", err);
+      });
+    }
+    module2.exports = findNodeModules2;
+    module2.exports.default = findNodeModules2;
+  }
+});
+
 // src/index.ts
-console.log("binary-collections main script :P");
+var index_exports = {};
+__export(index_exports, {
+  findNodeModules: () => import_find_node_modules.default
+});
+module.exports = __toCommonJS(index_exports);
+init_cjs_shims();
+var import_find_node_modules = __toESM(require_find_node_modules());
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findNodeModules
+});

package/lib/index.d.mts

@@ -1,2 +1 @@
-
-export {  }
+export { default as findNodeModules } from './find-node-modules.mjs';

package/lib/index.d.ts

@@ -1,2 +1,2 @@
-
-export {  }
+import findNodeModules from "./find-node-modules";
+export { findNodeModules };

package/lib/index.js

@@ -1,2 +1,8 @@
-// src/index.ts
-console.log("binary-collections main script :P");
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findNodeModules = void 0;
+const find_node_modules_1 = __importDefault(require("./find-node-modules"));
+exports.findNodeModules = find_node_modules_1.default;

package/lib/index.mjs

@@ -1,9 +1,16 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
+  require_find_node_modules
+} from "./chunk-YX5U7XDR.mjs";
+import {
+  __toESM,
   init_esm_shims
-} from "./chunk-7MSZ52XC.mjs";
-import "./chunk-AVDT32AY.mjs";
+} from "./chunk-AASHBCRW.mjs";
 
 // src/index.ts
 init_esm_shims();
-console.log("binary-collections main script :P");
+var import_find_node_modules = __toESM(require_find_node_modules());
+var export_findNodeModules = import_find_node_modules.default;
+export {
+  export_findNodeModules as findNodeModules
+};

package/lib/npm-run-series.cjs

@@ -5,6 +5,12 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+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;
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -22,11 +28,144 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "node_modules/tsup/assets/cjs_shims.js"() {
+  }
+});
+
+// src/utils.js
+var require_utils = __commonJS({
+  "src/utils.js"(exports2, module2) {
+    init_cjs_shims();
+    var fs2 = require("fs");
+    var path2 = 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);
+      }
+      return fullPath;
+    }
+    module2.exports.joinPathPreserveDriveLetter = joinPathPreserveDriveLetter;
+    function getArgs2() {
+      return argv;
+    }
+    module2.exports.getArgs = getArgs2;
+    function del(fullPath) {
+      if (fs2.statSync(fullPath).isDirectory()) {
+        const subdir = fs2.readdirSync(fullPath).map((dirPath) => path2.resolve(fullPath, dirPath));
+        for (let i = 0; i < subdir.length; i++) {
+          del(subdir[i]);
+        }
+      } else {
+        try {
+          fs2.rmSync(fullPath, { recursive: true, force: true, retryDelay: 7e3 });
+          console.log("deleted", fullPath);
+        } catch (_) {
+          console.log("failed delete", fullPath);
+        }
+      }
+    }
+    module2.exports.del = del;
+    function delStream(globStream) {
+      globStream.stream().on("data", (result) => {
+        const fullPath = path2.resolve(process.cwd(), result);
+        if (fs2.statSync(fullPath).isDirectory()) {
+          const subdir = fs2.readdirSync(fullPath).map((dirPath) => path2.resolve(fullPath, dirPath));
+          for (let i = 0; i < subdir.length; i++) {
+            del(subdir[i]);
+          }
+        }
+        del(fullPath);
+      });
+    }
+    module2.exports.delStream = delStream;
+    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");
+    }
+    module2.exports.getFileTreeString = getFileTreeString;
+    var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    module2.exports.delay = delay;
+  }
+});
+
 // src/npm-run-series.js
+init_cjs_shims();
 var fs = require("fs");
 var path = require("path");
 var { Minimatch } = require("minimatch");
-var args = require("minimist")(process.argv.slice(2));
+var { getArgs } = require_utils();
+var args = getArgs();
 var cwd = process.cwd();
 var packagejson = path.join(cwd, "package.json");
 var verbose = args["v"] || args["verbose"];

package/lib/npm-run-series.d.ts

@@ -1 +1,2 @@
 #!/usr/bin/env node
+export {};

package/lib/npm-run-series.js

@@ -1,61 +1,86 @@
 #!/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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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());
+    });
 };
-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/npm-run-series.js
-var fs = require("fs");
-var path = require("path");
-var { Minimatch } = require("minimatch");
-var args = require("minimist")(process.argv.slice(2));
-var cwd = process.cwd();
-var packagejson = path.join(cwd, "package.json");
-var verbose = args["v"] || args["verbose"];
-var usingYarn = args["yarn"];
-(async function npmRunSeries() {
-  const { execa } = await import("execa");
-  if (fs.existsSync(packagejson)) {
-    const parse = JSON.parse(fs.readFileSync(packagejson, "utf-8"));
-    if (parse !== null && typeof parse === "object") {
-      if ("scripts" in parse) {
-        const patterns = args._;
-        const scripts = parse.scripts;
-        const scriptNames = Object.keys(scripts);
-        for (let i = 0; i < patterns.length; i++) {
-          const pattern = patterns[i];
-          const matcher = new Minimatch(pattern, { nonegate: true });
-          for (let ii = 0; ii < scriptNames.length; ii++) {
-            const scriptName = scriptNames[ii];
-            const match = matcher.match(scriptName);
-            if (verbose) console.log({ pattern, scriptName, match });
-            if (match === true) {
-              await execa(usingYarn ? "yarn" : "npm", ["run", scriptName], {
-                cwd,
-                stdio: "inherit"
-              });
+const fs = require("fs");
+const path = require("path");
+const { Minimatch } = require("minimatch");
+const { getArgs } = require("./utils.js");
+const args = getArgs();
+const cwd = process.cwd();
+const packagejson = path.join(cwd, "package.json");
+const verbose = args["v"] || args["verbose"];
+const usingYarn = args["yarn"];
+(function npmRunSeries() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { execa } = yield Promise.resolve().then(() => __importStar(require("execa")));
+        if (fs.existsSync(packagejson)) {
+            /**
+             * @type {import('../package.json')}
+             */
+            const parse = JSON.parse(fs.readFileSync(packagejson, "utf-8"));
+            if (parse !== null && typeof parse === "object") {
+                if ("scripts" in parse) {
+                    const patterns = args._;
+                    const scripts = parse.scripts;
+                    const scriptNames = Object.keys(scripts);
+                    for (let i = 0; i < patterns.length; i++) {
+                        const pattern = patterns[i];
+                        const matcher = new Minimatch(pattern, { nonegate: true });
+                        for (let ii = 0; ii < scriptNames.length; ii++) {
+                            const scriptName = scriptNames[ii];
+                            const match = matcher.match(scriptName);
+                            if (verbose)
+                                console.log({ pattern, scriptName, match });
+                            if (match === true) {
+                                yield execa(usingYarn ? "yarn" : "npm", ["run", scriptName], {
+                                    cwd,
+                                    stdio: "inherit"
+                                });
+                            }
+                        }
+                    }
+                }
             }
-          }
         }
-      }
-    }
-  }
+    });
 })();

package/lib/npm-run-series.mjs

@@ -1,18 +1,20 @@
 #!/usr/bin/env node
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
-  init_esm_shims
-} from "./chunk-7MSZ52XC.mjs";
+  require_utils
+} from "./chunk-APBWENF6.mjs";
 import {
-  __require
-} from "./chunk-AVDT32AY.mjs";
+  __require,
+  init_esm_shims
+} from "./chunk-AASHBCRW.mjs";
 
 // src/npm-run-series.js
 init_esm_shims();
 var fs = __require("fs");
 var path = __require("path");
 var { Minimatch } = __require("minimatch");
-var args = __require("minimist")(process.argv.slice(2));
+var { getArgs } = require_utils();
+var args = getArgs();
 var cwd = process.cwd();
 var packagejson = path.join(cwd, "package.json");
 var verbose = args["v"] || args["verbose"];