binary-collections 2.0.9 → 2.0.11

package/lib/chunk-FKI7IEB5.mjs

@@ -0,0 +1,172 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  __esm,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/ps/connected-domain.js
+function connected_domain_default(tdArray, indicator, hardlink) {
+  hardlink = hardlink || false;
+  if (!tdArray) {
+    throw new Error("tdArray must be provided");
+  }
+  if (!indicator) {
+    throw new Error("indicator must be provided");
+  }
+  tdArray = JSON.parse(JSON.stringify(tdArray));
+  var domains = {};
+  var domainUUID = 0;
+  var pointsHash = {};
+  tdArray.forEach(function(row, y) {
+    row.forEach(function(colItem, x) {
+      var identifier2 = indicator(colItem, x, y);
+      var neighbours = [];
+      if (tdArray[y - 1] && tdArray[y - 1][x] !== void 0) {
+        neighbours.push(pointsHash[x + "_" + (y - 1)]);
+      }
+      if (row[x - 1] !== void 0) {
+        neighbours.push(pointsHash[x - 1 + "_" + y]);
+      }
+      if (!hardlink) {
+        if (tdArray[y - 1] && tdArray[y - 1][x - 1] !== void 0) {
+          neighbours.push(pointsHash[x - 1 + "_" + (y - 1)]);
+        }
+        if (tdArray[y - 1] && tdArray[y - 1][x + 1] !== void 0) {
+          neighbours.push(pointsHash[x + 1 + "_" + (y - 1)]);
+        }
+      }
+      if (neighbours.length) {
+        var matched = false;
+        neighbours.forEach(function(neighbour) {
+          if (neighbour.identifier == identifier2) {
+            if (!matched) {
+              addPointToDomain(colItem, x, y, neighbour.domainId);
+              matched = true;
+            } else {
+              var colItemPoint = pointsHash[x + "_" + y];
+              if (neighbour.domainId != colItemPoint.domainId) {
+                mergeDomains(neighbour.domainId, colItemPoint.domainId);
+              }
+            }
+          }
+        });
+        if (!matched) {
+          addNewDomain(colItem, x, y, identifier2);
+        }
+      } else {
+        addNewDomain(colItem, x, y, identifier2);
+      }
+    });
+  });
+  var result = {
+    domains: [],
+    totalDomains: 0,
+    groupByIdentifier: {},
+    totalIdentifiers: 0
+  };
+  var domainId = null;
+  var identifier = null;
+  var domain = null;
+  for (domainId in domains) {
+    domain = domains[domainId];
+    domain.bounding = calculateBounding(domain.points);
+    identifier = domain.identifier;
+    result.domains.push(domain);
+    result.totalDomains++;
+    if (!(identifier in result.groupByIdentifier)) {
+      result.groupByIdentifier[identifier] = [];
+      result.totalIdentifiers++;
+    }
+    result.groupByIdentifier[identifier].push(domain);
+  }
+  function calculateBounding(points) {
+    var minX = null;
+    var minY = null;
+    var maxX = null;
+    var maxY = null;
+    points.forEach(function(point) {
+      if (minX === null || point.x < minX) {
+        minX = point.x;
+      }
+      if (minY === null || point.y < minY) {
+        minY = point.y;
+      }
+      if (maxX === null || point.x > maxX) {
+        maxX = point.x;
+      }
+      if (maxY === null || point.y > maxY) {
+        maxY = point.y;
+      }
+    });
+    var w = maxX - minX;
+    var h = maxY - minY;
+    return {
+      x: minX,
+      y: minY,
+      w,
+      h
+    };
+  }
+  function addNewDomain(point, x, y, identifier2) {
+    var newDomain = {
+      identifier: identifier2,
+      domainId: ++domainUUID,
+      bounding: {},
+      points: []
+    };
+    var newPoint = {
+      value: point,
+      x,
+      y,
+      identifier: identifier2,
+      domainId: newDomain.domainId
+    };
+    pointsHash[x + "_" + y] = {
+      value: point,
+      identifier: identifier2,
+      domainId: newDomain.domainId
+    };
+    newDomain.points.push(newPoint);
+    domains[newDomain.domainId] = newDomain;
+  }
+  function addPointToDomain(point, x, y, domainId2) {
+    var domain2 = domains[domainId2];
+    var newPoint = {
+      value: point,
+      x,
+      y,
+      identifier: domain2.identifier,
+      domainId: domainId2
+    };
+    pointsHash[x + "_" + y] = {
+      value: point,
+      identifier: domain2.identifier,
+      domainId: domainId2
+    };
+    domain2.points.push(newPoint);
+  }
+  function mergeDomains(domainAId, domainBId) {
+    var domainA = domains[domainAId];
+    var domainB = domains[domainBId];
+    if (domainA.identifier == domainB.identifier) {
+      domainB.domainId = domainA.domainId;
+      domainB.points.forEach(function(point) {
+        point.domainId = domainA.domainId;
+        pointsHash[point.x + "_" + point.y].domainId = domainA.domainId;
+      });
+      domainA.points = domainA.points.concat(domainB.points);
+      delete domains[domainBId];
+    }
+  }
+  return result;
+}
+var init_connected_domain = __esm({
+  "src/ps/connected-domain.js"() {
+    init_esm_shims();
+  }
+});
+
+export {
+  connected_domain_default,
+  init_connected_domain
+};

package/lib/chunk-GEYA2USY.mjs

@@ -0,0 +1,207 @@
+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";
+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}`;
+}
+function parseGitHubUrl(url) {
+  const ghRepoRoot = /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/?$/;
+  const ghTreeOrBlob = /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/(tree|blob)\/([^/]+(?:\/[^/]+)*)/;
+  const ghRaw = /^https:\/\/raw\.githubusercontent\.com\/([^/]+)\/([^/]+)\/([^/]+)(\/.+)?$/;
+  const ghDotComRaw = /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/raw\/([^/]+)\/.+$/;
+  let match;
+  if (match = url.match(ghRaw)) {
+    const [, owner, repo, branch] = match;
+    return { owner, repo, branch, url };
+  }
+  if (match = url.match(ghDotComRaw)) {
+    const [, owner, repo, branch] = match;
+    return { owner, repo, branch, url };
+  }
+  if (match = url.match(ghTreeOrBlob)) {
+    const [, owner, repo, , branchPath] = match;
+    return { owner, repo, branch: branchPath, url };
+  }
+  if (match = url.match(ghRepoRoot)) {
+    const [, owner, repo] = match;
+    return { owner, repo, url };
+  }
+  throw new Error(`Unsupported GitHub URL: ${url}`);
+}
+
+export {
+  fetchJson,
+  getLatestCommit,
+  getLatestCommitAcrossBranches,
+  replaceRawWithLatestHash,
+  parseGitHubUrl
+};