binary-collections 2.0.6 → 2.0.8

package/lib/utils.js

@@ -1,35 +1,181 @@
-// src/utils.js
-var { fs, path } = require("sbg-utility");
-var argv = require("minimist")(process.argv.slice(2));
+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 path = require("upath");
+const argv = require("minimist")(process.argv.slice(2));
+const { exec } = require("child_process");
+const { URL } = require("url");
+const { promisify } = require("util");
+/**
+ * Promisified version of Node.js exec function for async shell command execution.
+ * @type {(command: string) => Promise<{ stdout: string, stderr: string }>}
+ */
+const execAsync = promisify(exec);
+function parseGitRemotes() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            // Run the `git remote -v` command
+            const { stdout } = yield execAsync("git remote -v");
+            // Split the output into lines
+            const lines = stdout.split("\n");
+            // Object to hold the remotes
+            const remotes = {};
+            // Process each line
+            lines.forEach((line) => {
+                const [name, url] = line.split("\t");
+                if (name && url) {
+                    const [repoUrl] = url.split(" ");
+                    try {
+                        // Parse the URL
+                        const parsedUrl = new URL(repoUrl);
+                        // Extract the path from the URL
+                        const pathParts = parsedUrl.pathname.split("/").filter(Boolean);
+                        // Check if the URL is from GitHub and has the username/repo format
+                        if (parsedUrl.hostname === "github.com" && pathParts.length === 2) {
+                            // Remove the `.git` suffix if present
+                            let repoPath = pathParts.join("/");
+                            if (repoPath.endsWith(".git")) {
+                                repoPath = repoPath.slice(0, -4); // Remove the `.git` suffix
+                            }
+                            remotes[name] = repoPath;
+                        }
+                    }
+                    catch (e) {
+                        console.error("URL Parsing Error:", e.message);
+                    }
+                }
+            });
+            return remotes;
+        }
+        catch (error) {
+            console.error("Error:", error.message);
+            return {};
+        }
+    });
+}
+module.exports.parseGitRemotes = parseGitRemotes;
+/**
+ * Joins all given path segments together and normalizes the resulting path.
+ * Preserves the case of the drive letter on Windows.
+ *
+ * @param {...string} segments Path segments to join.
+ * @returns {string} Normalized path with drive letter case preserved.
+ */
+function joinPathPreserveDriveLetter(...segments) {
+    let fullPath = require("path").join(...segments);
+    // Check if the path starts with a drive letter (e.g., C:\)
+    if (/^[a-z]:\\/.test(fullPath)) {
+        // Convert the drive letter to uppercase
+        fullPath = fullPath.charAt(0).toUpperCase() + fullPath.slice(1);
+    }
+    return fullPath;
+}
+module.exports.joinPathPreserveDriveLetter = joinPathPreserveDriveLetter;
+/**
+ * Returns parsed command line arguments using minimist.
+ * @returns {import('minimist').ParsedArgs} Parsed command line arguments
+ */
 function getArgs() {
-  return argv;
+    return argv;
 }
-function delStream(globStream) {
-  globStream.stream().on("data", (result) => {
-    const fullPath = path.resolve(process.cwd(), result);
+module.exports.getArgs = getArgs;
+/**
+ * Recursively deletes a file or directory at the given path.
+ * @param {string} fullPath Absolute path to the file or directory to delete.
+ */
+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]);
-      }
+        // delete all files each package directory
+        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: 7000 });
+            console.log("deleted", fullPath);
+        }
+        catch (_) {
+            console.log("failed delete", fullPath);
+        }
     }
-    del(fullPath);
-  });
 }
-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]);
+module.exports.del = del;
+/**
+ * Handles a glob stream to delete matched files and directories recursively.
+ * @param {glob.Glob} globStream Glob stream object.
+ */
+function delStream(globStream) {
+    globStream.stream().on("data", (result) => {
+        const fullPath = path.resolve(process.cwd(), result);
+        if (fs.statSync(fullPath).isDirectory()) {
+            // delete all files each package directory
+            const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
+            for (let i = 0; i < subdir.length; i++) {
+                del(subdir[i]);
+            }
+        }
+        del(fullPath);
+    });
+}
+module.exports.delStream = delStream;
+/**
+ * Creates a directory/file tree string from an array of file paths and hashes.
+ * @param {string[]} hashArray Array of strings in the format 'relative/path/to/file hash'.
+ * @returns {string} Directory/file tree as a string, with file hashes.
+ */
+function getFileTreeString(hashArray) {
+    const tree = {};
+    // Map file paths to hashes for quick lookup
+    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; // file
+            }
+            else {
+                current[part] = current[part] || {};
+                current = current[part];
+            }
+        }
     }
-  } else {
-    try {
-      fs.rmSync(fullPath, { recursive: true, force: true, retryDelay: 7e3 });
-      console.log("deleted", fullPath);
-    } catch (_) {
-      console.log("failed delete", fullPath);
+    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 ? "└── " : "├── ";
+            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 ? "    " : "│   "), currentPath));
+            }
+        });
+        return lines;
     }
-  }
+    return printNode(tree, "", "").join("\n");
 }
-var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-module.exports = { del, delStream, getArgs, delay };
+module.exports.getFileTreeString = getFileTreeString;
+/**
+ * Creates an async delay for the specified number of milliseconds.
+ * @param {number} ms Number of milliseconds to delay.
+ * @returns {Promise<void>} Promise that resolves after the specified delay.
+ */
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+module.exports.delay = delay;

package/lib/utils.mjs

@@ -1,7 +1,6 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
   require_utils
-} from "./chunk-LPLPQBYP.mjs";
-import "./chunk-7MSZ52XC.mjs";
-import "./chunk-AVDT32AY.mjs";
+} from "./chunk-APBWENF6.mjs";
+import "./chunk-AASHBCRW.mjs";
 export default require_utils();

package/lib/yarn-reinstall.cjs

@@ -0,0 +1,44 @@
+"use strict";
+const { execSync } = require("child_process");
+const { getArgs } = require("./utils.js");
+const args = getArgs();
+const positional = args._ || [];
+if (positional.length === 0) {
+    console.error("Usage: yarn-reinstall <packageName> [--dev|-D|--peer|-P|--optional|-O]");
+    process.exit(1);
+}
+const packageName = positional[0];
+const flags = positional.slice(1).concat(Object.keys(args)
+    .filter((k) => k !== "_" && args[k] === true)
+    .map((k) => `--${k}`));
+if (!packageName) {
+    console.error("Please provide a package name.");
+    process.exit(1);
+}
+// Remove and add commands
+const removeCmd = `yarn remove ${packageName}`;
+const addCmd = `yarn add ${packageName} ${flags.join(" ")}`.trim();
+try {
+    // Check if the package is installed before removing
+    let isInstalled = false;
+    try {
+        const listOutput = execSync(`yarn list --pattern "${packageName}" --depth=0`, { encoding: "utf8" });
+        isInstalled = listOutput.includes(packageName + "@");
+    }
+    catch (_e) {
+        // If yarn list fails, assume not installed
+        isInstalled = false;
+    }
+    if (isInstalled) {
+        console.log(`Running: ${removeCmd}`);
+        execSync(removeCmd, { stdio: "inherit" });
+    }
+    else {
+        console.warn(`Package "${packageName}" was not installed or not referenced, skipping remove.`);
+    }
+    console.log(`Running: ${addCmd}`);
+    execSync(addCmd, { stdio: "inherit" });
+}
+catch (err) {
+    process.exit(err.status || 1);
+}

package/lib/yarn-reinstall.d.cts

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

package/lib/yarn-reinstall.d.mts

@@ -0,0 +1,49 @@
+const { execSync } = require("child_process");
+const { getArgs } = require("./utils.js");
+const args = getArgs();
+const positional = args._ || [];
+
+if (positional.length === 0) {
+  console.error("Usage: yarn-reinstall <packageName> [--dev|-D|--peer|-P|--optional|-O]");
+  process.exit(1);
+}
+
+const packageName = positional[0];
+const flags = positional.slice(1).concat(
+  Object.keys(args)
+    .filter((k) => k !== "_" && args[k] === true)
+    .map((k) => `--${k}`)
+);
+
+if (!packageName) {
+  console.error("Please provide a package name.");
+  process.exit(1);
+}
+
+// Remove and add commands
+const removeCmd = `yarn remove ${packageName}`;
+const addCmd = `yarn add ${packageName} ${flags.join(" ")}`.trim();
+
+try {
+  // Check if the package is installed before removing
+  let isInstalled = false;
+  try {
+    const listOutput = execSync(`yarn list --pattern "${packageName}" --depth=0`, { encoding: "utf8" });
+    isInstalled = listOutput.includes(packageName + "@");
+  } catch (_e) {
+    // If yarn list fails, assume not installed
+    isInstalled = false;
+  }
+
+  if (isInstalled) {
+    console.log(`Running: ${removeCmd}`);
+    execSync(removeCmd, { stdio: "inherit" });
+  } else {
+    console.warn(`Package "${packageName}" was not installed or not referenced, skipping remove.`);
+  }
+
+  console.log(`Running: ${addCmd}`);
+  execSync(addCmd, { stdio: "inherit" });
+} catch (err) {
+  process.exit(err.status || 1);
+}

package/lib/yarn-reinstall.d.ts

@@ -0,0 +1,49 @@
+const { execSync } = require("child_process");
+const { getArgs } = require("./utils.js");
+const args = getArgs();
+const positional = args._ || [];
+
+if (positional.length === 0) {
+  console.error("Usage: yarn-reinstall <packageName> [--dev|-D|--peer|-P|--optional|-O]");
+  process.exit(1);
+}
+
+const packageName = positional[0];
+const flags = positional.slice(1).concat(
+  Object.keys(args)
+    .filter((k) => k !== "_" && args[k] === true)
+    .map((k) => `--${k}`)
+);
+
+if (!packageName) {
+  console.error("Please provide a package name.");
+  process.exit(1);
+}
+
+// Remove and add commands
+const removeCmd = `yarn remove ${packageName}`;
+const addCmd = `yarn add ${packageName} ${flags.join(" ")}`.trim();
+
+try {
+  // Check if the package is installed before removing
+  let isInstalled = false;
+  try {
+    const listOutput = execSync(`yarn list --pattern "${packageName}" --depth=0`, { encoding: "utf8" });
+    isInstalled = listOutput.includes(packageName + "@");
+  } catch (_e) {
+    // If yarn list fails, assume not installed
+    isInstalled = false;
+  }
+
+  if (isInstalled) {
+    console.log(`Running: ${removeCmd}`);
+    execSync(removeCmd, { stdio: "inherit" });
+  } else {
+    console.warn(`Package "${packageName}" was not installed or not referenced, skipping remove.`);
+  }
+
+  console.log(`Running: ${addCmd}`);
+  execSync(addCmd, { stdio: "inherit" });
+} catch (err) {
+  process.exit(err.status || 1);
+}

package/lib/yarn-reinstall.mjs

@@ -0,0 +1,54 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_utils
+} from "./chunk-APBWENF6.mjs";
+import {
+  __commonJS,
+  __require,
+  init_esm_shims
+} from "./chunk-AASHBCRW.mjs";
+
+// src/yarn-reinstall.cjs
+var require_yarn_reinstall = __commonJS({
+  "src/yarn-reinstall.cjs"() {
+    init_esm_shims();
+    var { execSync } = __require("child_process");
+    var { getArgs } = require_utils();
+    var args = getArgs();
+    var positional = args._ || [];
+    if (positional.length === 0) {
+      console.error("Usage: yarn-reinstall <packageName> [--dev|-D|--peer|-P|--optional|-O]");
+      process.exit(1);
+    }
+    var packageName = positional[0];
+    var flags = positional.slice(1).concat(
+      Object.keys(args).filter((k) => k !== "_" && args[k] === true).map((k) => `--${k}`)
+    );
+    if (!packageName) {
+      console.error("Please provide a package name.");
+      process.exit(1);
+    }
+    var removeCmd = `yarn remove ${packageName}`;
+    var addCmd = `yarn add ${packageName} ${flags.join(" ")}`.trim();
+    try {
+      let isInstalled = false;
+      try {
+        const listOutput = execSync(`yarn list --pattern "${packageName}" --depth=0`, { encoding: "utf8" });
+        isInstalled = listOutput.includes(packageName + "@");
+      } catch (_e) {
+        isInstalled = false;
+      }
+      if (isInstalled) {
+        console.log(`Running: ${removeCmd}`);
+        execSync(removeCmd, { stdio: "inherit" });
+      } else {
+        console.warn(`Package "${packageName}" was not installed or not referenced, skipping remove.`);
+      }
+      console.log(`Running: ${addCmd}`);
+      execSync(addCmd, { stdio: "inherit" });
+    } catch (err) {
+      process.exit(err.status || 1);
+    }
+  }
+});
+export default require_yarn_reinstall();