binary-collections 2.0.10 → 2.0.11

package/lib/utils/findWorkspaceRoot.cjs

@@ -0,0 +1,70 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/findWorkspaceRoot.js
+var findWorkspaceRoot_exports = {};
+__export(findWorkspaceRoot_exports, {
+  findWorkspaceRoot: () => findYarnWorkspaceRootFS,
+  findWorkspaceRootYC: () => findWorkspaceRootYC,
+  findYarnWorkspaceRootFS: () => findYarnWorkspaceRootFS
+});
+module.exports = __toCommonJS(findWorkspaceRoot_exports);
+var import_core = require("@yarnpkg/core");
+var import_upath = __toESM(require("upath"), 1);
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+async function findWorkspaceRootYC(cwd = process.cwd()) {
+  const configuration = await import_core.Configuration.find(cwd, null);
+  const { project } = await import_core.Project.find(configuration, cwd);
+  return project.cwd;
+}
+function findYarnWorkspaceRootFS(cwd = process.cwd()) {
+  let current = import_upath.default.resolve(cwd);
+  while (true) {
+    const pkgPath = import_upath.default.join(current, "package.json");
+    if (import_fs_extra.default.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(import_fs_extra.default.readFileSync(pkgPath, "utf8"));
+        if (pkg.workspaces || import_fs_extra.default.existsSync(import_upath.default.join(current, "yarn.lock")) || import_fs_extra.default.existsSync(import_upath.default.join(current, ".yarn"))) {
+          return current;
+        }
+      } catch {
+      }
+    }
+    const parent = import_upath.default.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findWorkspaceRoot,
+  findWorkspaceRootYC,
+  findYarnWorkspaceRootFS
+});

package/lib/utils/findWorkspaceRoot.d.ts

@@ -0,0 +1,9 @@
+export function findWorkspaceRootYC(cwd?: string): Promise<import("@yarnpkg/fslib").PortablePath>;
+/**
+ * Find Yarn workspace root directory.
+ *
+ * @param {string} cwd
+ * @returns {string|null}
+ */
+export function findYarnWorkspaceRootFS(cwd?: string): string | null;
+export { findYarnWorkspaceRootFS as findWorkspaceRoot };

package/lib/utils/findWorkspaceRoot.js

@@ -0,0 +1,57 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findWorkspaceRootYC = findWorkspaceRootYC;
+exports.findYarnWorkspaceRootFS = findYarnWorkspaceRootFS;
+exports.findWorkspaceRoot = findYarnWorkspaceRootFS;
+const core_1 = require("@yarnpkg/core");
+const upath_1 = __importDefault(require("upath"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+function findWorkspaceRootYC() {
+    return __awaiter(this, arguments, void 0, function* (cwd = process.cwd()) {
+        const configuration = yield core_1.Configuration.find(cwd, null);
+        const { project } = yield core_1.Project.find(configuration, cwd);
+        return project.cwd;
+    });
+}
+/**
+ * Find Yarn workspace root directory.
+ *
+ * @param {string} cwd
+ * @returns {string|null}
+ */
+function findYarnWorkspaceRootFS(cwd = process.cwd()) {
+    let current = upath_1.default.resolve(cwd);
+    while (true) {
+        const pkgPath = upath_1.default.join(current, "package.json");
+        if (fs_extra_1.default.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(fs_extra_1.default.readFileSync(pkgPath, "utf8"));
+                if (pkg.workspaces ||
+                    fs_extra_1.default.existsSync(upath_1.default.join(current, "yarn.lock")) ||
+                    fs_extra_1.default.existsSync(upath_1.default.join(current, ".yarn"))) {
+                    return current;
+                }
+            }
+            catch (_a) {
+                // ignore invalid package.json
+            }
+        }
+        const parent = upath_1.default.dirname(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
+    }
+}

package/lib/utils/findWorkspaceRoot.mjs

@@ -0,0 +1,40 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "../chunk-QQ4A6DLD.mjs";
+
+// src/utils/findWorkspaceRoot.js
+init_esm_shims();
+import { Configuration, Project } from "@yarnpkg/core";
+import path from "upath";
+import fs from "fs-extra";
+async function findWorkspaceRootYC(cwd = process.cwd()) {
+  const configuration = await Configuration.find(cwd, null);
+  const { project } = await Project.find(configuration, cwd);
+  return project.cwd;
+}
+function findYarnWorkspaceRootFS(cwd = process.cwd()) {
+  let current = path.resolve(cwd);
+  while (true) {
+    const pkgPath = path.join(current, "package.json");
+    if (fs.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        if (pkg.workspaces || fs.existsSync(path.join(current, "yarn.lock")) || fs.existsSync(path.join(current, ".yarn"))) {
+          return current;
+        }
+      } catch {
+      }
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+export {
+  findYarnWorkspaceRootFS as findWorkspaceRoot,
+  findWorkspaceRootYC,
+  findYarnWorkspaceRootFS
+};

package/lib/utils/index.cjs

@@ -50,31 +50,78 @@ function getArgs() {
 }
 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/utils/index.mjs

@@ -1,6 +1,6 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
   require_utils
-} from "../chunk-V3N3JEUF.mjs";
+} from "../chunk-Z6JLYU2J.mjs";
 import "../chunk-QQ4A6DLD.mjs";
 export default require_utils();

package/lib/utils/isGithubTokenValid.cjs

@@ -0,0 +1,64 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/isGithubTokenValid.js
+var isGithubTokenValid_exports = {};
+__export(isGithubTokenValid_exports, {
+  isGitHubTokenValid: () => isGitHubTokenValid
+});
+module.exports = __toCommonJS(isGithubTokenValid_exports);
+var import_node_https = __toESM(require("https"), 1);
+async function isGitHubTokenValid(token) {
+  if (!token || typeof token !== "string") {
+    return false;
+  }
+  return new Promise((resolve) => {
+    const req = import_node_https.default.request(
+      {
+        hostname: "api.github.com",
+        path: "/user",
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "User-Agent": "github-token-validator",
+          Accept: "application/vnd.github+json"
+        }
+      },
+      (res) => {
+        resolve(res.statusCode === 200);
+        res.resume();
+      }
+    );
+    req.on("error", () => resolve(false));
+    req.end();
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isGitHubTokenValid
+});

package/lib/utils/isGithubTokenValid.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Check whether a GitHub token is valid.
+ *
+ * @param {string} token GitHub personal access token
+ * @returns {Promise<boolean>}
+ */
+export function isGitHubTokenValid(token: string): Promise<boolean>;

package/lib/utils/isGithubTokenValid.js

@@ -0,0 +1,48 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGitHubTokenValid = isGitHubTokenValid;
+const node_https_1 = __importDefault(require("node:https"));
+/**
+ * Check whether a GitHub token is valid.
+ *
+ * @param {string} token GitHub personal access token
+ * @returns {Promise<boolean>}
+ */
+function isGitHubTokenValid(token) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!token || typeof token !== "string") {
+            return false;
+        }
+        return new Promise((resolve) => {
+            const req = node_https_1.default.request({
+                hostname: "api.github.com",
+                path: "/user",
+                method: "GET",
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    "User-Agent": "github-token-validator",
+                    Accept: "application/vnd.github+json"
+                }
+            }, (res) => {
+                // 200 = valid token
+                resolve(res.statusCode === 200);
+                // consume response to avoid memory leak
+                res.resume();
+            });
+            req.on("error", () => resolve(false));
+            req.end();
+        });
+    });
+}

package/lib/utils/isGithubTokenValid.mjs

@@ -0,0 +1,36 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "../chunk-QQ4A6DLD.mjs";
+
+// src/utils/isGithubTokenValid.js
+init_esm_shims();
+import https from "https";
+async function isGitHubTokenValid(token) {
+  if (!token || typeof token !== "string") {
+    return false;
+  }
+  return new Promise((resolve) => {
+    const req = https.request(
+      {
+        hostname: "api.github.com",
+        path: "/user",
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "User-Agent": "github-token-validator",
+          Accept: "application/vnd.github+json"
+        }
+      },
+      (res) => {
+        resolve(res.statusCode === 200);
+        res.resume();
+      }
+    );
+    req.on("error", () => resolve(false));
+    req.end();
+  });
+}
+export {
+  isGitHubTokenValid
+};

package/lib/yarn-reinstall.cjs

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
@@ -67,31 +68,78 @@ var require_utils = __commonJS({
     }
     module2.exports.getArgs = getArgs2;
     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);
       }
     }
     module2.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);
       });
     }
     module2.exports.delStream = delStream;

package/lib/yarn-reinstall.mjs

@@ -1,7 +1,7 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
   require_utils
-} from "./chunk-V3N3JEUF.mjs";
+} from "./chunk-Z6JLYU2J.mjs";
 import {
   __commonJS,
   __require,