binary-collections 2.0.9 → 2.0.11

package/lib/chunk-XA3SNBPA.mjs

@@ -0,0 +1,184 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  findEnvFiles
+} from "./chunk-ID2WBTE2.mjs";
+import {
+  require_utils
+} from "./chunk-Z6JLYU2J.mjs";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/package-resolutions-updater.mjs
+init_esm_shims();
+var utils = __toESM(require_utils(), 1);
+import * as dotenv from "dotenv";
+import fs from "fs";
+import https from "https";
+import os from "os";
+import path from "path";
+import { parseGitHubUrl } from "git-command-helper";
+var projectDir = process.cwd();
+var envPath = path.join(projectDir, ".env");
+var args = utils.getArgs();
+if (!fs.existsSync(envPath)) {
+  const envFiles = findEnvFiles(projectDir, (file) => {
+    const content = fs.readFileSync(file, "utf-8");
+    return /GITHUB_TOKEN|ACCESS_TOKEN/.test(content);
+  });
+  if (envFiles.length > 0) {
+    envPath = envFiles[0];
+  }
+}
+if (fs.existsSync(envPath)) {
+  dotenv.config({ path: envPath, quiet: true, override: true });
+}
+var ACCESS_TOKEN = process.env.GITHUB_TOKEN || process.env.ACCESS_TOKEN;
+if (args.help || args.h) {
+  showHelp();
+}
+function showHelp() {
+  const helpText = `
+GitHub Package Resolutions Updater
+Usage:
+  node src/package-resolutions-updater.mjs [options]
+Options:
+  --help, -h           Show this help message
+Description:
+  Updates the commit hashes in package.json's 'resolutions' field for GitHub tarball URLs to point to the latest commit SHA of the corresponding repository and branch.
+Features:
+  - Parses GitHub URLs to extract repository owner, name, and branch.
+  - Fetches the latest commit SHA across all branches using GitHub's API.
+  - Replaces the old branch or commit in the URL with the latest SHA.
+  - Overwrites package.json with the updated URLs.
+Requirements:
+  - GitHub Personal Access Token (GITHUB_TOKEN) via .env
+  - ESM support (type: "module" in package.json)
+  - Node.js v18+ recommended
+Dependencies:
+  - ansi-colors \u2013 for styled terminal output
+  - dotenv \u2013 to load GitHub token from .env
+Examples:
+  node src/package-resolutions-updater.mjs
+  node src/package-resolutions-updater.mjs --help
+
+`;
+  console.log(helpText);
+  process.exit(0);
+}
+var GITHUB_USER_AGENTS = [
+  "octokit-rest.js/19.0.7",
+  "GitHub CLI/2.40.0",
+  "Mozilla/5.0 (compatible; GitHubCopilot/1.0)",
+  "PostmanRuntime/7.32.3",
+  "binary-collections-resolver/1.0 (+https://github.com/dimaslanjaka/bin)"
+];
+var userAgentDir = path.join(os.tmpdir(), "nodejs");
+var userAgentFile = path.join(userAgentDir, "useragent.txt");
+var selectedUserAgent;
+try {
+  if (!fs.existsSync(userAgentDir)) fs.mkdirSync(userAgentDir, { recursive: true });
+  if (fs.existsSync(userAgentFile)) {
+    const fileAgent = fs.readFileSync(userAgentFile, "utf-8").trim();
+    if (GITHUB_USER_AGENTS.includes(fileAgent)) {
+      selectedUserAgent = fileAgent;
+    }
+  }
+  if (!selectedUserAgent) {
+    selectedUserAgent = GITHUB_USER_AGENTS[Math.floor(Math.random() * GITHUB_USER_AGENTS.length)];
+    fs.writeFileSync(userAgentFile, selectedUserAgent, "utf-8");
+  }
+} catch (_e) {
+  selectedUserAgent = GITHUB_USER_AGENTS[Math.floor(Math.random() * GITHUB_USER_AGENTS.length)];
+}
+function fetchJson(url) {
+  const headers = {
+    "User-Agent": selectedUserAgent,
+    Accept: "application/vnd.github.v3+json",
+    "X-GitHub-Api-Version": "2022-11-28",
+    ...ACCESS_TOKEN ? { Authorization: `token ${ACCESS_TOKEN}` } : {}
+  };
+  return new Promise((resolve, reject) => {
+    https.get(url, { headers }, (res) => {
+      let data = "";
+      res.on("data", (chunk) => data += chunk);
+      res.on("end", () => {
+        try {
+          const json = JSON.parse(data);
+          if (res.statusCode < 200 || res.statusCode >= 300) {
+            return reject(
+              new Error(`GitHub API Error ${res.statusCode}: ${json.message || "Unknown error"}
+URL: ${url}`)
+            );
+          }
+          resolve(json);
+        } catch {
+          reject(new Error(`Invalid JSON from: ${url}`));
+        }
+      });
+    }).on("error", reject);
+  });
+}
+async function getLatestCommit(owner, repo, branch = "main") {
+  var _a, _b, _c, _d;
+  const url = `https://api.github.com/repos/${owner}/${repo}/commits/${branch}`;
+  const json = await fetchJson(url);
+  const sha = json.sha;
+  const dateStr = ((_b = (_a = json.commit) == null ? void 0 : _a.committer) == null ? void 0 : _b.date) || ((_d = (_c = json.commit) == null ? void 0 : _c.author) == null ? void 0 : _d.date);
+  if (!sha || !dateStr) {
+    console.log(json);
+    throw new Error(`Missing SHA or date for ${owner}/${repo}@${branch}`);
+  }
+  return {
+    owner,
+    repo,
+    branch,
+    sha,
+    date: new Date(dateStr).toISOString()
+  };
+}
+async function getLatestCommitAcrossBranches(owner, repo) {
+  const branches = await fetchJson(`https://api.github.com/repos/${owner}/${repo}/branches`);
+  const commits = await Promise.all(
+    branches.map(async ({ name, commit }) => {
+      var _a, _b, _c, _d;
+      const commitSha = commit == null ? void 0 : commit.sha;
+      if (!commitSha) {
+        console.warn(`No commit SHA for '${owner}/${repo}' branch: ${name}`);
+        return { branch: name, sha: "", date: /* @__PURE__ */ new Date(0) };
+      }
+      try {
+        const commitData = await fetchJson(`https://api.github.com/repos/${owner}/${repo}/commits/${commitSha}`);
+        const dateStr = ((_b = (_a = commitData.commit) == null ? void 0 : _a.committer) == null ? void 0 : _b.date) || ((_d = (_c = commitData.commit) == null ? void 0 : _c.author) == null ? void 0 : _d.date);
+        const date = dateStr ? new Date(dateStr) : /* @__PURE__ */ new Date(0);
+        return { branch: name, sha: commitData.sha, date };
+      } catch (e) {
+        console.warn(`Failed to fetch commit for ${name}: ${e.message}`);
+        return { branch: name, sha: commitSha, date: /* @__PURE__ */ new Date(0) };
+      }
+    })
+  );
+  const latest = commits.reduce((a, b) => a.date > b.date ? a : b, { date: /* @__PURE__ */ new Date(0) });
+  return {
+    owner,
+    repo,
+    branch: latest.branch,
+    sha: latest.sha,
+    date: latest.date.toISOString()
+  };
+}
+function replaceRawWithLatestHash(url, latestHash) {
+  const match = url.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+)\/raw\/([^/]+)\/(.+)$/);
+  if (!match) throw new Error("Invalid GitHub raw URL");
+  const [, owner, repo, _oldHash, path2] = match;
+  return `https://github.com/${owner}/${repo}/raw/${latestHash}/${path2}`;
+}
+
+export {
+  parseGitHubUrl,
+  fetchJson,
+  getLatestCommit,
+  getLatestCommitAcrossBranches,
+  replaceRawWithLatestHash
+};

package/lib/chunk-XVBFFVCJ.mjs

@@ -0,0 +1,209 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  connected_domain_default,
+  init_connected_domain
+} from "./chunk-FKI7IEB5.mjs";
+import {
+  __esm,
+  __export,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/ps/table-parser.js
+var table_parser_exports = {};
+__export(table_parser_exports, {
+  parse: () => parse
+});
+function parse(output) {
+  var linesTmp = output.split(/(\r\n)|(\n\r)|\n|\r/);
+  var lines = [];
+  var titleInfo = {};
+  var twoDimArray = [];
+  linesTmp.forEach(function(line) {
+    if (line && line.trim()) {
+      lines.push(line);
+    }
+  });
+  lines.forEach(function(line, index) {
+    if (index == 0) {
+      var fields = line.split(/\s+/);
+      var currentIndex = 0;
+      fields.forEach(function(field, idx) {
+        if (field) {
+          var info = titleInfo[field] = {};
+          var indexBegin = line.indexOf(field, currentIndex);
+          var indexEnd = currentIndex = indexBegin + field.length;
+          if (idx == 0) {
+            info.titleBegin = 0;
+          } else {
+            info.titleBegin = indexBegin;
+          }
+          if (idx == fields.length - 1) {
+            info.titleEnd = line.length - 1;
+          } else {
+            info.titleEnd = indexEnd;
+          }
+        }
+      });
+    } else {
+      twoDimArray[index - 1] = line.split("");
+    }
+  });
+  var connectedDomains = connected_domain_default(
+    twoDimArray,
+    function(value) {
+      if (EMPTY_EX.test(value)) {
+        return -1;
+      } else {
+        return 1;
+      }
+    },
+    true
+  );
+  var valuesDomainsVerticalGroups = [];
+  connectedDomains.domains.sort(function(a, b) {
+    return a.bounding.x - b.bounding.x;
+  });
+  connectedDomains.domains.forEach(function(domain) {
+    if (domain.identifier === 1) {
+      var overlapped = false;
+      valuesDomainsVerticalGroups.forEach(function(group) {
+        var bounding = domain.bounding;
+        var left = bounding.x;
+        var right = bounding.x + bounding.w;
+        if (overlap(left, right, group.begin, group.end)) {
+          overlapped = true;
+          group.domains.push(domain);
+          group.begin = group.begin > left ? left : group.begin;
+          group.end = group.end < right ? right : group.end;
+        }
+      });
+      if (!overlapped) {
+        valuesDomainsVerticalGroups.push({
+          begin: domain.bounding.x,
+          end: domain.bounding.x + domain.bounding.w,
+          domains: [domain]
+        });
+      }
+    }
+  });
+  valuesDomainsVerticalGroups.forEach(function(group) {
+    var title = null;
+    var info = null;
+    var overlapped = false;
+    var minimunLeftDistance = null;
+    var nearestLeftTitle = null;
+    var distance = null;
+    for (title in titleInfo) {
+      info = titleInfo[title];
+      if (group.begin > info.titleBegin) {
+        distance = group.begin - info.titleBegin;
+        if (!nearestLeftTitle || distance < minimunLeftDistance) {
+          nearestLeftTitle = title;
+          minimunLeftDistance = distance;
+        }
+      }
+      if (overlap(group.begin, group.end, info.titleBegin, info.titleEnd)) {
+        overlapped = true;
+        info.titleBegin = info.titleBegin > group.begin ? group.begin : info.titleBegin;
+        info.titleEnd = info.titleEnd < group.end ? group.end : info.titleEnd;
+      }
+    }
+    if (!overlapped && nearestLeftTitle) {
+      var nearestTitleField = titleInfo[nearestLeftTitle];
+      nearestTitleField.titleBegin = nearestTitleField.titleBegin > group.begin ? group.begin : nearestTitleField.titleBegin;
+      nearestTitleField.titleEnd = nearestTitleField.titleEnd < group.end ? group.end : nearestTitleField.titleEnd;
+    }
+  });
+  var result = [];
+  lines.forEach(function(line, index) {
+    if (index > 0) {
+      var lineItem = {};
+      var title = null;
+      var info = null;
+      var value = null;
+      for (title in titleInfo) {
+        info = titleInfo[title];
+        value = line.substring(info.titleBegin, info.titleEnd + 1);
+        lineItem[title] = splitValue(value.trim());
+      }
+      result.push(lineItem);
+    }
+  });
+  return result;
+}
+function overlap(begin1, end1, begin2, end2) {
+  return begin1 > begin2 && begin1 < end2 || // 2--1--2--1 or 2--1--1--2
+  end1 > begin2 && end1 < end2 || // 1--2--1--2 or 2--1--1--2
+  begin1 <= begin2 && end1 >= end2;
+}
+function splitValue(value) {
+  var match = value.match(/"/g);
+  if (!match || match.length == 1) {
+    return value.split(/\s+/);
+  } else {
+    var result = [];
+    var chunk = null;
+    var ifInWrappedChunk = false;
+    var ifInPureWrappedChunk = false;
+    var quotaCount = 0;
+    var maxQuotaCount = match.length % 2 == 0 ? match.length : match.length - 1;
+    var previousItem = null;
+    var values = value.split("");
+    values.forEach(function(item, index) {
+      if (item !== " ") {
+        if (item === '"') {
+          if (ifInWrappedChunk === false && quotaCount <= maxQuotaCount) {
+            ifInWrappedChunk = true;
+            quotaCount++;
+            if (previousItem === " " || previousItem === null) {
+              ifInPureWrappedChunk = true;
+              chunk = "";
+            } else {
+              chunk += item;
+            }
+          } else if (ifInWrappedChunk === true) {
+            ifInWrappedChunk = false;
+            quotaCount++;
+            if (ifInPureWrappedChunk === true) {
+              ifInPureWrappedChunk = false;
+              result.push(chunk);
+              chunk = null;
+            } else {
+              chunk += item;
+            }
+          }
+        } else if (ifInWrappedChunk === false && (previousItem === " " || previousItem === null)) {
+          chunk = item;
+        } else {
+          chunk += item;
+        }
+      } else if (ifInWrappedChunk) {
+        chunk += item;
+      } else if (chunk !== null) {
+        result.push(chunk);
+        chunk = null;
+      }
+      previousItem = item;
+      if (index == values.length - 1 && chunk !== null) {
+        result.push(chunk);
+        chunk = null;
+      }
+    });
+    return result;
+  }
+}
+var EMPTY_EX;
+var init_table_parser = __esm({
+  "src/ps/table-parser.js"() {
+    init_esm_shims();
+    init_connected_domain();
+    EMPTY_EX = /\s/;
+  }
+});
+
+export {
+  parse,
+  table_parser_exports,
+  init_table_parser
+};

package/lib/chunk-YYLIQQKF.mjs

@@ -0,0 +1,31 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  __commonJS,
+  __require,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/binary-collections-config.cjs
+var require_binary_collections_config = __commonJS({
+  "src/binary-collections-config.cjs"(exports, module) {
+    init_esm_shims();
+    var path = __require("path");
+    __require("dotenv").config({ path: path.join(process.cwd(), ".env"), quiet: true, override: true });
+    function getTempDir() {
+      return process.env.TEMP_DIR || path.join(process.cwd(), "tmp");
+    }
+    function getTempPath(...segments) {
+      return path.join(getTempDir(), ...segments);
+    }
+    var TEMP_BASE_DIR = getTempDir();
+    module.exports = {
+      getTempDir,
+      getTempPath,
+      TEMP_BASE_DIR
+    };
+  }
+});
+
+export {
+  require_binary_collections_config
+};

package/lib/{chunk-APBWENF6.mjs → chunk-Z6JLYU2J.mjs}

@@ -3,11 +3,11 @@ import {
   __commonJS,
   __require,
   init_esm_shims
-} from "./chunk-AASHBCRW.mjs";
+} from "./chunk-QQ4A6DLD.mjs";
 
-// src/utils.js
+// src/utils/index.cjs
 var require_utils = __commonJS({
-  "src/utils.js"(exports, module) {
+  "src/utils/index.cjs"(exports, module) {
     init_esm_shims();
     var fs = __require("fs");
     var path = __require("upath");
@@ -60,31 +60,78 @@ var require_utils = __commonJS({
     }
     module.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);
       }
     }
     module.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);
       });
     }
     module.exports.delStream = delStream;

package/lib/chunk-ZDMWBSYF.mjs

@@ -0,0 +1,81 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_gitattributes
+} from "./chunk-PDN26I7O.mjs";
+import {
+  require_utils
+} from "./chunk-A3VUZEJK.mjs";
+import {
+  __commonJS,
+  __require,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/git/line-endings.cjs
+var require_line_endings = __commonJS({
+  "src/git/line-endings.cjs"(exports, module) {
+    init_esm_shims();
+    var path = __require("upath");
+    var fs = __require("fs");
+    var { runGitCommand } = require_utils();
+    var { updateGitAttributes } = require_gitattributes();
+    function forceLfLineEndings() {
+      console.log("\n=== Configuring LF Line Endings ===");
+      runGitCommand(["config", "core.autocrlf", "false"], "Disable automatic CRLF conversion");
+      runGitCommand(["config", "core.eol", "lf"], "Set end-of-line to LF");
+      const gitattributesPath = path.join(process.cwd(), ".gitattributes");
+      if (fs.existsSync(gitattributesPath)) {
+        let content = fs.readFileSync(gitattributesPath, "utf8");
+        if (!/^\*\s+text=auto\s+eol=lf/m.test(content)) {
+          content = `* text=auto eol=lf
+` + content;
+          fs.writeFileSync(gitattributesPath, content);
+        }
+      }
+      const desiredRules = [
+        { pattern: "*", attributes: "text=auto eol=lf", priority: 1 },
+        {
+          pattern: "*.{cmd,bat,ps1,sh,cmd1,cmd2,bat1,bat2,vbs}",
+          attributes: "text eol=crlf",
+          priority: 2
+        },
+        {
+          pattern: "*.{png,jpg,jpeg,gif,ico,svg,bmp,webp,avif,tiff,tif,psd,ai,eps,raw}",
+          attributes: "binary",
+          priority: 3
+        },
+        {
+          pattern: "*.{zip,tar,gz,7z,rar,exe,dll,so,bin,jar,war,ear,apk,msi,deb,rpm,iso,img,dmg,pdf,mp3,mp4,mov,avi,mkv,flv,wmv,ogg,webm,wav,aac,m4a,otf,ttf,woff,woff2,eot}",
+          attributes: "binary",
+          priority: 3
+        }
+      ];
+      const result = updateGitAttributes(gitattributesPath, desiredRules);
+      if (result.error) {
+        console.log(`[\u2717] Error updating .gitattributes: ${result.error}`);
+        return;
+      }
+      if (result.conflicts.length > 0) {
+        console.log("\n[!] Detected conflicts in .gitattributes:");
+        result.conflicts.forEach((conflict) => {
+          console.log(`    ${conflict.pattern}: ${conflict.existing} -> ${conflict.proposed} (${conflict.action})`);
+        });
+      }
+      if (result.success) {
+        console.log(`[\u2713] ${result.message}:`);
+        result.changes.forEach((change) => {
+          console.log(`    ${change.action}: ${change.pattern} ${change.attributes}`);
+        });
+      } else {
+        console.log(`[i] ${result.message}`);
+      }
+    }
+    module.exports = {
+      forceLfLineEndings
+    };
+  }
+});
+
+export {
+  require_line_endings
+};