binary-collections 2.0.8 → 2.0.10

package/lib/print-directory-tree.cjs

@@ -1,220 +1,286 @@
-"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());
-    });
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
-const fs = require("fs").promises;
-const path = require("path");
-const crypto = require("crypto");
-const { execSync } = require("child_process");
-const glob = require("glob");
-const { getArgs } = require("./utils.js");
-const sbgUtil = require("sbg-utility");
-const dotenv = require("dotenv");
-const projectDir = process.cwd();
-const envPath = path.join(projectDir, ".env");
-// Load the .env file using dotenv (ESM import)
-if (fs.existsSync(envPath))
-    dotenv.config({ path: envPath });
-// Parse CLI arguments
-const argv = getArgs();
-// Main logic wrapped in an async function
-function main() {
-    return __awaiter(this, void 0, void 0, function* () {
-        // Determine output file from CLI args
-        let relativeOutputFile = "tmp/directory-structure.txt";
-        if (argv.output || argv.o) {
-            relativeOutputFile = argv.output || argv.o;
-        }
-        // If not absolute, resolve relative to projectDir
-        const outputFile = path.isAbsolute(relativeOutputFile)
-            ? relativeOutputFile
-            : path.join(projectDir, relativeOutputFile);
-        // Create or clear the hash file
-        sbgUtil.writefile(outputFile, "");
-        /**
-         * List of file extensions to include
-         * @type {string[]}
-         */
-        let extensions = [];
-        if (argv.ext) {
-            extensions = argv.ext
-                .split(",")
-                .map((e) => e.trim().replace(/^\./, ""))
-                .filter(Boolean);
-        }
-        // Directories to exclude
-        let excludeDirs = [
-            "node_modules",
-            "vendor",
-            "venv",
-            ".venv",
-            ".git",
-            ".hg",
-            ".svn",
-            ".idea",
-            ".vscode",
-            "dist",
-            "build",
-            "out",
-            "coverage",
-            ".DS_Store"
-        ];
-        if (argv.exclude) {
-            const userExcludes = argv.exclude
-                .split(",")
-                .map((d) => d.trim())
-                .filter(Boolean);
-            if (argv["override-exclude"] || argv.we) {
-                // Override the default excludes with user-provided ones
-                excludeDirs = userExcludes;
-            }
-            else {
-                // Append user-provided excludes to the default ones
-                excludeDirs = excludeDirs.concat(userExcludes);
-            }
-        }
-        // Convert excludeDirs into glob ignore patterns
-        const ignorePatterns = excludeDirs.map((dir) => `**/${dir}/**`);
-        // Initialize an array to hold the formatted outputs
-        let hashArray = [];
-        // Helper function to hash and add file if not already processed
-        const processedFiles = new Set();
-        /**
-         * Hashes a file and pushes its relative path and hash to the hashArray.
-         * @param {string} file - The absolute path to the file.
-         * @returns {Promise<void>} Resolves when the file has been processed and added to hashArray.
-         */
-        function hashAndPush(file) {
-            return __awaiter(this, void 0, void 0, function* () {
-                if (processedFiles.has(file))
-                    return;
-                processedFiles.add(file);
-                let relativePath = path.relative(projectDir, file);
-                relativePath = relativePath.split(path.sep).join("/");
-                try {
-                    const stats = yield fs.stat(file);
-                    const pseudoHash = `${stats.size}-${stats.mtimeMs}`;
-                    const hash = crypto.createHash("sha256").update(pseudoHash).digest("hex");
-                    hashArray.push(`${relativePath} ${hash.slice(0, 8)}`);
-                }
-                catch (err) {
-                    console.error(`Error processing file: ${file}`, err instanceof Error ? err.message : "<unknown error>");
-                    if (err && err.code === "ENOENT") {
-                        hashArray.push(`${relativePath} <file not found>`);
-                    }
-                    else {
-                        hashArray.push(`${relativePath} <error: ${err && err.code ? `code ${err.code}` : "unknown"}>`);
-                    }
+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"() {
+  }
+});
+
+// src/utils/index.cjs
+var require_utils = __commonJS({
+  "src/utils/index.cjs"(exports2, module2) {
+    init_cjs_shims();
+    var fs2 = require("fs");
+    var path2 = require("upath");
+    var argv2 = 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);
                 }
-            });
-        }
-        // Collect all files to process (extensions + special files)
-        const initialFiles = [
-            path.join(projectDir, "package.json"),
-            path.join(projectDir, "composer.json"),
-            path.join(projectDir, "requirements.txt")
-        ];
-        let patterns = [];
-        if (argv.pattern) {
-            if (Array.isArray(argv.pattern)) {
-                patterns = argv.pattern.map((p) => p.trim()).filter(Boolean);
-            }
-            else {
-                patterns = [argv.pattern.trim()];
+                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 argv2;
+    }
+    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 if (extensions.length === 0) {
-            patterns = ["**/*.*"];
+      } else {
+        try {
+          fs2.rmSync(fullPath, { recursive: true, force: true, retryDelay: 7e3 });
+          console.log("deleted", fullPath);
+        } catch (_) {
+          console.log("failed delete", fullPath);
         }
-        else {
-            patterns = extensions.map((ext) => `**/*.${ext}`);
+      }
+    }
+    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]);
+          }
         }
-        const globFiles = glob.sync(patterns.length === 1 ? patterns[0] : `{${patterns.join(",")}}`, {
-            cwd: projectDir,
-            ignore: ignorePatterns,
-            absolute: true,
-            nodir: true
-        });
-        const allFiles = new Set([...initialFiles, ...globFiles]);
-        // Hash all unique files
-        yield Promise.all(Array.from(allFiles).map(hashAndPush));
-        // Sort the hashArray by file paths
-        hashArray.sort((a, b) => a.localeCompare(b));
-        /**
-         * Generates a directory/file tree string from a hash array of file paths and hashes.
-         *
-         * @param {string[]} hashArray - Array of strings in the format 'relative/path/to/file hash'.
-         * @returns {string} The 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];
-                    }
-                }
-            }
-            /**
-             * Recursively builds the tree string for a given node.
-             *
-             * @param {Object} node - The current node in the tree.
-             * @param {string} prefix - The prefix for the current tree level.
-             * @param {string} parentPath - The path to the current node.
-             * @returns {string[]} Array of lines representing the tree structure.
-             */
-            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) {
-                        // file: show hash
-                        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");
+        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];
+          }
         }
-        // Write directory/file tree to the output file (hashes are included in the tree)
-        const fileTreeString = getFileTreeString(hashArray);
-        yield fs.writeFile(outputFile, fileTreeString + "\n", "utf-8");
-        // Add the hash file to the commit if --git-add is present
-        if (argv["git-add"]) {
-            execSync(`git add ${relativeOutputFile}`);
-            console.log(`Directory tree written to ${relativeOutputFile} and staged for git.`);
+      }
+      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/print-directory-tree.cjs
+init_cjs_shims();
+var fs = require("fs").promises;
+var path = require("path");
+var crypto = require("crypto");
+var { execSync } = require("child_process");
+var glob = require("glob");
+var { getArgs } = require_utils();
+var sbgUtil = require("sbg-utility");
+var dotenv = require("dotenv");
+var projectDir = process.cwd();
+var envPath = path.join(projectDir, ".env");
+if (fs.existsSync(envPath)) dotenv.config({ path: envPath });
+var argv = getArgs();
+async function main() {
+  let relativeOutputFile = "tmp/directory-structure.txt";
+  if (argv.output || argv.o) {
+    relativeOutputFile = argv.output || argv.o;
+  }
+  const outputFile = path.isAbsolute(relativeOutputFile) ? relativeOutputFile : path.join(projectDir, relativeOutputFile);
+  sbgUtil.writefile(outputFile, "");
+  let extensions = [];
+  if (argv.ext) {
+    extensions = argv.ext.split(",").map((e) => e.trim().replace(/^\./, "")).filter(Boolean);
+  }
+  let excludeDirs = [
+    "node_modules",
+    "vendor",
+    "venv",
+    ".venv",
+    ".git",
+    ".hg",
+    ".svn",
+    ".idea",
+    ".vscode",
+    "dist",
+    "build",
+    "out",
+    "coverage",
+    ".DS_Store"
+  ];
+  if (argv.exclude) {
+    const userExcludes = argv.exclude.split(",").map((d) => d.trim()).filter(Boolean);
+    if (argv["override-exclude"] || argv.we) {
+      excludeDirs = userExcludes;
+    } else {
+      excludeDirs = excludeDirs.concat(userExcludes);
+    }
+  }
+  const ignorePatterns = excludeDirs.map((dir) => `**/${dir}/**`);
+  let hashArray = [];
+  const processedFiles = /* @__PURE__ */ new Set();
+  async function hashAndPush(file) {
+    if (processedFiles.has(file)) return;
+    processedFiles.add(file);
+    let relativePath = path.relative(projectDir, file);
+    relativePath = relativePath.split(path.sep).join("/");
+    try {
+      const stats = await fs.stat(file);
+      const pseudoHash = `${stats.size}-${stats.mtimeMs}`;
+      const hash = crypto.createHash("sha256").update(pseudoHash).digest("hex");
+      hashArray.push(`${relativePath} ${hash.slice(0, 8)}`);
+    } catch (err) {
+      console.error(`Error processing file: ${file}`, err instanceof Error ? err.message : "<unknown error>");
+      if (err && err.code === "ENOENT") {
+        hashArray.push(`${relativePath} <file not found>`);
+      } else {
+        hashArray.push(`${relativePath} <error: ${err && err.code ? `code ${err.code}` : "unknown"}>`);
+      }
+    }
+  }
+  const initialFiles = [
+    path.join(projectDir, "package.json"),
+    path.join(projectDir, "composer.json"),
+    path.join(projectDir, "requirements.txt")
+  ];
+  let patterns = [];
+  if (argv.pattern) {
+    if (Array.isArray(argv.pattern)) {
+      patterns = argv.pattern.map((p) => p.trim()).filter(Boolean);
+    } else {
+      patterns = [argv.pattern.trim()];
+    }
+  } else if (extensions.length === 0) {
+    patterns = ["**/*.*"];
+  } else {
+    patterns = extensions.map((ext) => `**/*.${ext}`);
+  }
+  const globFiles = glob.sync(patterns.length === 1 ? patterns[0] : `{${patterns.join(",")}}`, {
+    cwd: projectDir,
+    ignore: ignorePatterns,
+    absolute: true,
+    nodir: true
+  });
+  const allFiles = /* @__PURE__ */ new Set([...initialFiles, ...globFiles]);
+  await Promise.all(Array.from(allFiles).map(hashAndPush));
+  hashArray.sort((a, b) => a.localeCompare(b));
+  function getFileTreeString(hashArray2) {
+    const tree = {};
+    const hashMap = {};
+    for (const entry of hashArray2) {
+      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];
         }
-        else {
-            console.log(`Directory tree written to ${relativeOutputFile}.`);
+      }
+    }
+    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");
+  }
+  const fileTreeString = getFileTreeString(hashArray);
+  await fs.writeFile(outputFile, fileTreeString + "\n", "utf-8");
+  if (argv["git-add"]) {
+    execSync(`git add ${relativeOutputFile}`);
+    console.log(`Directory tree written to ${relativeOutputFile} and staged for git.`);
+  } else {
+    console.log(`Directory tree written to ${relativeOutputFile}.`);
+  }
 }
 if (argv.help || argv.h) {
-    console.log(`
+  console.log(`
 Usage: node print-directory-tree.cjs [options]
 
 Options:
@@ -232,10 +298,9 @@ Examples:
   node print-directory-tree.cjs --exclude=dist,build
   node print-directory-tree.cjs --output=tmp/tree.txt
 `);
-    process.exit(0);
+  process.exit(0);
 }
-// Execute the main function
 main().catch((err) => {
-    console.error(err);
-    process.exit(1);
+  console.error(err);
+  process.exit(1);
 });

package/lib/print-directory-tree.mjs

@@ -1,12 +1,12 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
   require_utils
-} from "./chunk-APBWENF6.mjs";
+} from "./chunk-V3N3JEUF.mjs";
 import {
   __commonJS,
   __require,
   init_esm_shims
-} from "./chunk-AASHBCRW.mjs";
+} from "./chunk-QQ4A6DLD.mjs";
 
 // src/print-directory-tree.cjs
 var require_print_directory_tree = __commonJS({

package/lib/ps/connected-domain.cjs

@@ -1,5 +1,28 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
 // src/ps/connected-domain.js
-module.exports = function(tdArray, indicator, hardlink) {
+var connected_domain_exports = {};
+__export(connected_domain_exports, {
+  default: () => connected_domain_default
+});
+module.exports = __toCommonJS(connected_domain_exports);
+function connected_domain_default(tdArray, indicator, hardlink) {
   hardlink = hardlink || false;
   if (!tdArray) {
     throw new Error("tdArray must be provided");
@@ -153,4 +176,4 @@ module.exports = function(tdArray, indicator, hardlink) {
     }
   }
   return result;
-};
+}

package/lib/ps/connected-domain.d.ts

@@ -1,2 +1,10 @@
-declare function _exports(tdArray: any[], indicator: Function, hardlink: boolean): any;
-export = _exports;
+/**
+ * calculate all the connected domains based on the given two-dimensional array
+ */
+/**
+ * @param {Array} tdArray
+ * @param {Function} indicator It receive the raw point data as the first parameter and decide what kind of domain the point belongs to, it should return a string as a domain identifier.
+ * @param {Boolean} hardlink If use hard link. Default to false.
+ * @return {Object} [{ bounding: { w: 12, h: 19, x: 0, y: 1 }, points: [ { x: 1, y: 2, point: {} } ], identifier: 'blue', domainId: 1 } ]
+ */
+export default function _default(tdArray: any[], indicator: Function, hardlink: boolean): any;

package/lib/ps/connected-domain.js

@@ -1,13 +1,16 @@
+"use strict";
 /**
  * calculate all the connected domains based on the given two-dimensional array
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
 /**
  * @param {Array} tdArray
  * @param {Function} indicator It receive the raw point data as the first parameter and decide what kind of domain the point belongs to, it should return a string as a domain identifier.
  * @param {Boolean} hardlink If use hard link. Default to false.
  * @return {Object} [{ bounding: { w: 12, h: 19, x: 0, y: 1 }, points: [ { x: 1, y: 2, point: {} } ], identifier: 'blue', domainId: 1 } ]
  */
-module.exports = function (tdArray, indicator, hardlink) {
+function default_1(tdArray, indicator, hardlink) {
     hardlink = hardlink || false;
     if (!tdArray) {
         throw new Error("tdArray must be provided");
@@ -199,4 +202,4 @@ module.exports = function (tdArray, indicator, hardlink) {
         }
     }
     return result;
-};
+}

package/lib/ps/connected-domain.mjs

@@ -1,6 +1,10 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
-  require_connected_domain
-} from "../chunk-DPKAJKFO.mjs";
-import "../chunk-AASHBCRW.mjs";
-export default require_connected_domain();
+  connected_domain_default,
+  init_connected_domain
+} from "../chunk-FKI7IEB5.mjs";
+import "../chunk-QQ4A6DLD.mjs";
+init_connected_domain();
+export {
+  connected_domain_default as default
+};