binary-collections 2.0.11 → 2.0.13

package/lib/chunk-RDGDLSPD.mjs

@@ -0,0 +1,76 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/rmpath.mjs
+init_esm_shims();
+import dotenv from "dotenv";
+import fs from "fs-extra";
+import * as glob from "glob";
+import path from "upath";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var dotenvPath = path.resolve(process.cwd(), ".env");
+if (fs.existsSync(dotenvPath)) {
+  dotenv.config({ path: dotenvPath, override: true, quiet: true });
+}
+var deletePatterns = [];
+function resolveDeletePatterns(targetPath) {
+  if (fs.existsSync(targetPath) && fs.lstatSync(targetPath).isFile()) {
+    deletePatterns.push(targetPath);
+    return;
+  }
+  const vowels = ["a", "i", "u", "e", "o", "A", "I", "U", "E", "O"];
+  const letters = [];
+  for (let i = 97; i <= 122; i++) letters.push(String.fromCharCode(i));
+  for (let i = 65; i <= 90; i++) letters.push(String.fromCharCode(i));
+  for (const letter of letters) {
+    for (const vowel of vowels) {
+      deletePatterns.push(
+        `.${letter}*`,
+        `@${letter}*`,
+        `${letter}*`,
+        `@${letter}${vowel}*`,
+        `.${letter}${vowel}*`,
+        `${letter}${vowel}*`
+      );
+    }
+  }
+}
+async function deleteMatchingFiles(baseDir) {
+  for (const pattern of deletePatterns) {
+    if (fs.existsSync(pattern)) {
+      fs.rmSync(pattern, { recursive: true, force: true });
+      continue;
+    }
+    const matches = glob.sync(path.join(baseDir, pattern), { dot: true, nocase: true });
+    for (const fpath of matches) {
+      try {
+        console.log(`deleting ${fpath}`);
+        fs.rmSync(fpath, { recursive: true, force: true });
+      } catch (_e) {
+        console.error(`cannot delete ${fpath}`);
+      }
+    }
+  }
+}
+async function deleteMainScript(targetPath) {
+  if (!fs.existsSync(targetPath)) {
+    targetPath = path.resolve(process.cwd(), targetPath);
+  }
+  resolveDeletePatterns(targetPath);
+  await deleteMatchingFiles(targetPath);
+  console.log(`cleaning ${targetPath}`);
+  try {
+    fs.rmSync(targetPath, { recursive: true, force: true });
+  } catch (_e) {
+  }
+}
+
+export {
+  resolveDeletePatterns,
+  deleteMatchingFiles,
+  deleteMainScript
+};

package/lib/chunk-RDN6HF5Z.mjs

@@ -0,0 +1,79 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_package
+} from "./chunk-NQXUYO67.mjs";
+import {
+  __commonJS,
+  __dirname,
+  __require,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/binary-collections/findScript.cjs
+var require_findScript = __commonJS({
+  "src/binary-collections/findScript.cjs"(exports, module) {
+    init_esm_shims();
+    var { glob } = __require("glob");
+    var path = __require("upath");
+    var fs = __require("fs-extra");
+    var pkgJson = require_package();
+    function findScript(scriptName, searchDir = null) {
+      if (!searchDir) searchDir = path.join(__dirname, "..");
+      let result;
+      const ignorePatterns = [
+        `**/*config*.{cjs,js,mjs}`,
+        `**/utils.{cjs,js,mjs}`,
+        `**/index.{cjs,js,mjs}`,
+        `**/chunk-*.{cjs,js,mjs}`,
+        `**/*.d.{ts,cts,mts}`
+        // ignore TypeScript declaration files
+      ];
+      try {
+        const pattern = `${scriptName}.{cjs,js,mjs}`;
+        const files = glob.sync(pattern, {
+          cwd: searchDir,
+          ignore: ignorePatterns,
+          absolute: true
+        });
+        if (files.length > 0) {
+          result = files[0];
+        } else {
+          if (pkgJson.bin[scriptName]) {
+            const find = [
+              path.join(searchDir, pkgJson.bin[scriptName]),
+              path.join(process.cwd(), "node_modules/binary-collections", pkgJson.bin[scriptName]),
+              path.join(__dirname, pkgJson.bin[scriptName]),
+              path.join(path.join(__dirname, ".."), pkgJson.bin[scriptName]),
+              path.join(path.join(__dirname, "../.."), pkgJson.bin[scriptName])
+            ];
+            const filtered = find.filter((file) => fs.existsSync(file));
+            if (filtered.length > 0) {
+              result = filtered[0];
+            } else {
+              console.warn(`\u26A0\uFE0F  Script "${scriptName}" not found in ${searchDir}.`);
+              console.warn(`\u{1F50D} Searched for: ${pattern} in ${searchDir}`);
+            }
+          }
+        }
+      } catch (error) {
+        console.error(`\u{1F50D} Error searching for script: ${error.message}`);
+      }
+      if (result && !result.includes("-cli")) {
+        const ext = path.extname(result);
+        const filename = path.basename(result, ext);
+        const cliFile = path.join(path.dirname(result), `${filename}-cli${ext}`);
+        if (fs.existsSync(cliFile)) {
+          result = cliFile;
+          console.log(`\u{1F50D} Found CLI version: ${cliFile}`);
+        }
+      }
+      return result;
+    }
+    module.exports = findScript;
+    module.exports.default = findScript;
+  }
+});
+
+export {
+  require_findScript
+};

package/lib/chunk-RJKTSUAX.mjs

@@ -0,0 +1,123 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/node-package-packer/build-readme.mjs
+init_esm_shims();
+import fs from "fs-extra";
+import path from "upath";
+import * as crossSpawn from "cross-spawn";
+import { gitCommandHelper as gch } from "git-command-helper";
+async function buildReadme(dirname, packagejson, releaseDir, argv, isCI) {
+  if (!fs.existsSync(path.join(dirname, ".git"))) {
+    console.log("Not a git repository, skipping readme creation");
+    return;
+  }
+  const spawnAsync = crossSpawn && typeof crossSpawn.async === "function" ? crossSpawn.async : crossSpawn;
+  if (isCI) {
+    await spawnAsync("git", ["config", "--global", "user.name", "dimaslanjaka"], {
+      cwd: dirname,
+      stdio: "inherit"
+    });
+    await spawnAsync("git", ["config", "--global", "user.email", "dimaslanjaka@gmail.com"], {
+      cwd: dirname,
+      stdio: "inherit"
+    });
+  }
+  const git = new gch(dirname);
+  const branch = (await git.getbranch()).filter((o) => o.active)[0].branch;
+  const gitlatest = await git.latestCommit();
+  const tarballs = fs.readdirSync(releaseDir).filter((str) => str.endsWith("tgz")).map((str) => {
+    return {
+      absolute: path.resolve(releaseDir, str),
+      relative: path.resolve(releaseDir, str).replace(path.toUnix(dirname), "")
+    };
+  }).filter((o) => fs.statSync(o.absolute).isFile());
+  let md = `# Release \`${packagejson.name}\` tarball
+`;
+  md += "## Releases\n";
+  md += "| version | tarball url |\n";
+  md += "| :--- | :--- |\n";
+  for (let i = 0; i < tarballs.length; i++) {
+    const tarball = tarballs[i];
+    const relativeTarball = tarball.relative.replace(/^\/+/, "");
+    if (!fs.existsSync(tarball.absolute)) {
+      console.log(tarball.relative, "not found");
+      continue;
+    }
+    await spawnAsync("git", ["update-index", "--untracked-cache"]);
+    if (argv["commit"]) {
+      const checkIgnore = await git.isIgnored(relativeTarball, { cwd: dirname });
+      if (checkIgnore) {
+        console.log(relativeTarball, "ignored by .gitignore");
+        continue;
+      } else {
+        await git.add(relativeTarball);
+        const args = ["status", "-uno", "--porcelain", "--", relativeTarball, "|", "wc", "-l"];
+        const isChanged = parseInt(
+          (await spawnAsync("git", args, {
+            cwd: dirname,
+            shell: true
+          })).output.trim()
+        ) > 0;
+        if (isChanged) {
+          await git.commit("chore(tarball): update " + gitlatest, "-m", { stdio: "pipe" });
+        }
+      }
+    }
+    const hash = await git.latestCommit(tarball.relative.replace(/^\/+/, ""));
+    const raw = await git.getGithubRepoUrl(tarball.relative.replace(/^\/+/, ""));
+    let tarballUrl;
+    const dev = raw.rawURL;
+    const prod = raw.rawURL.replace("/raw/" + branch, "/raw/" + hash);
+    let ver = path.basename(tarball.relative, ".tgz").replace(`${packagejson.name}-`, "");
+    if (typeof hash === "string") {
+      if (isNaN(parseFloat(ver))) {
+        ver = "latest";
+        tarballUrl = dev;
+        md += `| ${ver} | ${prod} |
+`;
+      } else {
+        tarballUrl = prod;
+      }
+      md += `| ${ver} | ${tarballUrl} |
+`;
+    }
+  }
+  md += `
+use this tarball with \`resolutions\`:
+`;
+  md += '```json\n{\n  "resolutions": {\n    "' + packagejson.name + '": "<url of tarball>"\n  }\n}\n```\n\n## Releases\n\n    ';
+  fs.writeFileSync(
+    path.join(releaseDir, "readme.md"),
+    (md + `
+
+## Get URL of \`${packagejson.name}\` Release Tarball
+- select tarball file
+![gambar](https://user-images.githubusercontent.com/12471057/203216375-8af4b5d9-00c2-40fb-8d3d-d220beaabd46.png)
+- copy raw url
+![gambar](https://user-images.githubusercontent.com/12471057/203216508-7590cbb9-a1ce-47d6-96ca-8d82149f0762.png)
+- or copy download url
+![gambar](https://user-images.githubusercontent.com/12471057/203216541-3807d2c3-5213-49f3-b93d-c626dbae3b2e.png)
+- then run installation from command line
+
+\`\`\`bash
+npm i https://....url-tgz
+\`\`\`
+for example
+\`\`\`bash
+npm i https://github.com/dimaslanjaka/nodejs-package-types/raw/main/release/nodejs-package-types.tgz
+\`\`\`
+
+## URL Parts Explanations
+> https://github.com/github-username/github-repo-name/raw/github-branch-name/path-to-file-with-extension
+  `).trim() + "\n"
+  );
+}
+var build_readme_default = buildReadme;
+
+export {
+  buildReadme,
+  build_readme_default
+};

package/lib/{chunk-XA3SNBPA.mjs → chunk-TBWXE7ST.mjs}

@@ -1,10 +1,13 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
-  findEnvFiles
-} from "./chunk-ID2WBTE2.mjs";
+  require_fetchResponse
+} from "./chunk-KLKAIFKI.mjs";
+import {
+  require_findEnvFiles
+} from "./chunk-H44UWUFY.mjs";
 import {
   require_utils
-} from "./chunk-Z6JLYU2J.mjs";
+} from "./chunk-6RK5UCTP.mjs";
 import {
   __toESM,
   init_esm_shims
@@ -13,17 +16,18 @@ import {
 // src/package-resolutions-updater.mjs
 init_esm_shims();
 var utils = __toESM(require_utils(), 1);
+var import_fetchResponse = __toESM(require_fetchResponse(), 1);
+var import_findEnvFiles = __toESM(require_findEnvFiles(), 1);
 import * as dotenv from "dotenv";
 import fs from "fs";
-import https from "https";
 import os from "os";
-import path from "path";
+import path from "upath";
 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 envFiles = (0, import_findEnvFiles.findEnvFiles)(projectDir, (file) => {
     const content = fs.readFileSync(file, "utf-8");
     return /GITHUB_TOKEN|ACCESS_TOKEN/.test(content);
   });
@@ -34,7 +38,7 @@ if (!fs.existsSync(envPath)) {
 if (fs.existsSync(envPath)) {
   dotenv.config({ path: envPath, quiet: true, override: true });
 }
-var ACCESS_TOKEN = process.env.GITHUB_TOKEN || process.env.ACCESS_TOKEN;
+var ACCESS_TOKEN = process.env.ACCESS_TOKEN || process.env.GITHUB_TOKEN;
 if (args.help || args.h) {
   showHelp();
 }
@@ -92,33 +96,23 @@ try {
 } 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 fetchJson(url) {
+  var _a;
+  const response = await (0, import_fetchResponse.default)(url, {
+    headers: {
+      "User-Agent": selectedUserAgent,
+      Accept: "application/vnd.github.v3+json",
+      "X-GitHub-Api-Version": "2022-11-28",
+      ...ACCESS_TOKEN ? { Authorization: `token ${ACCESS_TOKEN}` } : {}
+    },
+    responseType: "json"
   });
+  if (response.status < 200 || response.status >= 300) {
+    const message = ((_a = response.data) == null ? void 0 : _a.message) || "Unknown error";
+    throw new Error(`GitHub API Error ${response.status}: ${message}
+URL: ${url}`);
+  }
+  return response.data;
 }
 async function getLatestCommit(owner, repo, branch = "main") {
   var _a, _b, _c, _d;
@@ -169,10 +163,74 @@ async function getLatestCommitAcrossBranches(owner, repo) {
   };
 }
 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}`;
+  const parsed = parseGitHubUrl(url);
+  if (!parsed || !parsed.owner || !parsed.repo || !parsed.branch) {
+    throw new Error("Invalid GitHub raw URL");
+  }
+  const branchPrefix = `${parsed.branch}/`;
+  const rawPrefix = parsed.host === "github.com" ? `raw/${branchPrefix}` : branchPrefix;
+  const refsPrefix = `refs/heads/${branchPrefix}`;
+  const path2 = parsed.path.startsWith(rawPrefix) ? parsed.path.slice(rawPrefix.length) : parsed.path.startsWith(refsPrefix) ? parsed.path.slice(refsPrefix.length) : parsed.path.startsWith(branchPrefix) ? parsed.path.slice(branchPrefix.length) : parsed.path;
+  if (parsed.host === "github.com") {
+    return `https://github.com/${parsed.owner}/${parsed.repo}/raw/${latestHash}/${path2}`;
+  }
+  if (parsed.host === "raw.githubusercontent.com") {
+    return `https://raw.githubusercontent.com/${parsed.owner}/${parsed.repo}/${latestHash}/${path2}`;
+  }
+  throw new Error("Invalid GitHub raw URL");
+}
+async function resolvePackageResolutionUpdates(resolutions, specialPackageOverrides = []) {
+  const updates = [];
+  for (const [currentPkgName, url] of Object.entries(resolutions || {})) {
+    let repo;
+    try {
+      repo = parseGitHubUrl(url);
+    } catch (error) {
+      updates.push({
+        skipped: true,
+        currentPkgName,
+        url,
+        error
+      });
+      continue;
+    }
+    try {
+      const override = specialPackageOverrides.find((p) => p.pkg === currentPkgName);
+      const latest = override ? await getLatestCommit(override.owner, override.repo, override.branch) : await getLatestCommitAcrossBranches(repo.owner, repo.repo);
+      const new_url = replaceRawWithLatestHash(url, latest.sha);
+      const response = await (0, import_fetchResponse.default)(new_url);
+      if (response.status < 200 || response.status >= 300) {
+        updates.push({
+          failed: true,
+          currentPkgName,
+          url,
+          new_url,
+          repo,
+          latest,
+          error: new Error(`New URL not accessible (status ${response.status}).
+original: ${url}
+new: ${new_url}`)
+        });
+        continue;
+      }
+      updates.push({
+        currentPkgName,
+        url,
+        new_url,
+        repo,
+        latest
+      });
+    } catch (error) {
+      updates.push({
+        failed: true,
+        currentPkgName,
+        url,
+        repo,
+        error
+      });
+    }
+  }
+  return updates;
 }
 
 export {
@@ -180,5 +238,6 @@ export {
   fetchJson,
   getLatestCommit,
   getLatestCommitAcrossBranches,
-  replaceRawWithLatestHash
+  replaceRawWithLatestHash,
+  resolvePackageResolutionUpdates
 };

package/lib/chunk-UXCFNAR6.mjs

@@ -0,0 +1,55 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/node-cache-cleaner/yarn.ts
+init_esm_shims();
+import { spawn } from "cross-spawn";
+function yarnVersion() {
+  return new Promise((resolve, reject) => {
+    const process = spawn("yarn", ["--version"], {
+      stdio: "pipe",
+      shell: true
+    });
+    let version = "";
+    process.stdout.on("data", (data) => {
+      version += data.toString();
+    });
+    process.on("close", (code) => {
+      if (code === 0) {
+        resolve(version.trim());
+      } else {
+        reject(new Error(`Yarn version check failed with exit code ${code}`));
+      }
+    });
+  });
+}
+async function cleanYarnCache() {
+  let version = "";
+  try {
+    version = await yarnVersion();
+  } catch {
+  }
+  const major = parseInt(version.split(".")[0], 10);
+  const isClassic = major === 1 || version === "";
+  const args = isClassic ? ["cache", "clean"] : ["cache", "clean", "--all"];
+  return new Promise((resolve, reject) => {
+    const process = spawn("yarn", args, {
+      stdio: "inherit",
+      shell: true
+    });
+    process.on("close", (code) => {
+      if (code === 0) {
+        resolve(true);
+      } else {
+        reject(new Error(`Yarn cache clean failed with exit code ${code}`));
+      }
+    });
+  });
+}
+
+export {
+  yarnVersion,
+  cleanYarnCache
+};

package/lib/{chunk-M3YIYRHT.mjs → chunk-UY5VUEA3.mjs}

@@ -10,7 +10,7 @@ var require_find_node_modules = __commonJS({
   "src/find-node-modules.cjs"(exports, module) {
     init_esm_shims();
     var glob = __require("glob");
-    var path = __require("path");
+    var path = __require("upath");
     function findNodeModules(dir = process.cwd(), callback = null) {
       const finalDir = typeof dir === "string" ? dir : process.cwd();
       return new Promise((resolve, reject) => {

package/lib/chunk-WSHVPGNM.mjs

@@ -0,0 +1,44 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/run-by-checksum/hash.js
+init_esm_shims();
+import fs from "fs-extra";
+import * as glob from "glob";
+import upath from "upath";
+import path from "upath";
+import crypto from "crypto";
+function getAllFiles({ patterns, ignore, cwd }) {
+  const files = /* @__PURE__ */ new Set();
+  const root = cwd || process.cwd();
+  for (const pattern of patterns) {
+    const matched = glob.sync(pattern, {
+      cwd: root,
+      nodir: true,
+      ignore
+    });
+    for (const f of matched) {
+      files.add(upath.normalize(path.resolve(root, f)));
+    }
+  }
+  return [...files].sort();
+}
+function hashFile(file) {
+  const content = fs.readFileSync(file);
+  return crypto.createHash("sha256").update(content).digest("hex");
+}
+function buildChecksum(files) {
+  const hash = crypto.createHash("sha256");
+  for (const file of files) {
+    hash.update(file);
+    hash.update(hashFile(file));
+  }
+  return hash.digest("hex");
+}
+
+export {
+  getAllFiles,
+  buildChecksum
+};

package/lib/{chunk-66PAU5PS.mjs → chunk-X2B3X7D4.mjs}

@@ -1,16 +1,20 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_findEnvFiles
+} from "./chunk-H44UWUFY.mjs";
 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) {
+// src/binary-collections/config.cjs
+var require_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") });
+    var path = __require("upath");
+    var { findEnvWithToken } = require_findEnvFiles();
+    __require("dotenv").config({ path: findEnvWithToken(), quiet: true, overwrite: true });
     function getTempDir() {
       return process.env.TEMP_DIR || path.join(process.cwd(), "tmp");
     }
@@ -27,5 +31,5 @@ var require_binary_collections_config = __commonJS({
 });
 
 export {
-  require_binary_collections_config
+  require_config
 };