binary-collections 2.0.6 → 2.0.8

package/lib/{chunk-E75HJFJO.mjs → chunk-W3ENOM53.mjs}

@@ -1,10 +1,8 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
+  __commonJS,
   init_esm_shims
-} from "./chunk-7MSZ52XC.mjs";
-import {
-  __commonJS
-} from "./chunk-AVDT32AY.mjs";
+} from "./chunk-AASHBCRW.mjs";
 
 // src/ps/isWin.js
 var require_isWin = __commonJS({

package/lib/chunk-YV7DO3YV.mjs

@@ -0,0 +1,48 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  __commonJS,
+  __require,
+  init_esm_shims
+} from "./chunk-AASHBCRW.mjs";
+
+// src/git/normalize.cjs
+var require_normalize = __commonJS({
+  "src/git/normalize.cjs"(exports, module) {
+    init_esm_shims();
+    var { execSync } = __require("child_process");
+    function normalizeLineEndings() {
+      console.log("\n=== Normalizing Existing Files ===");
+      try {
+        const result = execSync("git ls-files", { encoding: "utf-8", stdio: "pipe" });
+        if (!result.trim()) {
+          console.log("[i] No tracked files to normalize");
+          return;
+        }
+        console.log("[i] Refreshing index to detect line ending changes...");
+        execSync("git add --renormalize .", { stdio: "pipe" });
+        try {
+          const statusResult = execSync("git status --porcelain", { encoding: "utf-8", stdio: "pipe" });
+          if (statusResult.trim()) {
+            console.log("[\u2713] Line endings normalized for tracked files");
+            console.log("[i] Files with updated line endings are now staged");
+            console.log("[i] Run 'git status' to see the changes");
+          } else {
+            console.log("[\u2713] All files already have correct line endings");
+          }
+        } catch {
+          console.log("[\u2713] Line ending normalization completed");
+        }
+      } catch (error) {
+        console.error("[\u2717] Failed to normalize line endings");
+        console.error(`Error: ${error.message}`);
+      }
+    }
+    module.exports = {
+      normalizeLineEndings
+    };
+  }
+});
+
+export {
+  require_normalize
+};

package/lib/chunk-YX5U7XDR.mjs

@@ -0,0 +1,58 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  __commonJS,
+  __require,
+  init_esm_shims
+} from "./chunk-AASHBCRW.mjs";
+
+// src/find-node-modules.js
+var require_find_node_modules = __commonJS({
+  "src/find-node-modules.js"(exports, module) {
+    init_esm_shims();
+    var glob = __require("glob");
+    var path = __require("path");
+    function findNodeModules(dir = process.cwd(), callback = null) {
+      const finalDir = typeof dir === "string" ? dir : process.cwd();
+      return new Promise((resolve, reject) => {
+        const results = [];
+        const g3 = new glob.Glob("**/node_modules", {
+          withFileTypes: false,
+          cwd: finalDir,
+          ignore: ["**/.git*", "**/vendor/**"]
+        });
+        const stream = g3.stream();
+        stream.on("data", (result) => {
+          const fullPath = path.resolve(finalDir, result);
+          if (typeof callback === "function") {
+            try {
+              callback(fullPath);
+            } catch (err) {
+              console.error("findNodeModules callback error:", err);
+            }
+          }
+          results.push(fullPath);
+        });
+        stream.on("error", (err) => reject(err));
+        stream.on("end", () => {
+          if (results.length === 0) {
+            console.log("No node_modules directories found.");
+          }
+          resolve(results);
+        });
+      });
+    }
+    if (typeof module !== "undefined" && __require.main === module) {
+      findNodeModules(null, console.log).then((dirs) => {
+        console.log(`Found ${dirs.length} node_modules directories.`);
+      }).catch((err) => {
+        console.error("Error finding node_modules directories:", err);
+      });
+    }
+    module.exports = findNodeModules;
+    module.exports.default = findNodeModules;
+  }
+});
+
+export {
+  require_find_node_modules
+};

package/lib/chunk-ZYAQRPUL.mjs

@@ -0,0 +1,28 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_utils
+} from "./chunk-EGSSKVDH.mjs";
+import {
+  __commonJS,
+  init_esm_shims
+} from "./chunk-AASHBCRW.mjs";
+
+// src/git/permissions.cjs
+var require_permissions = __commonJS({
+  "src/git/permissions.cjs"(exports, module) {
+    init_esm_shims();
+    var { runGitCommand } = require_utils();
+    function ignoreFilePermissions() {
+      console.log("\n=== Configuring File Permissions ===");
+      runGitCommand(["config", "core.filemode", "false"], "Ignore file permission changes");
+      runGitCommand(["config", "diff.ignoreSubmodules", "dirty"], "Ignore submodule permission changes");
+    }
+    module.exports = {
+      ignoreFilePermissions
+    };
+  }
+});
+
+export {
+  require_permissions
+};

package/lib/clean-github-actions-caches.cjs

@@ -0,0 +1,162 @@
+"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());
+    });
+};
+const axios = require("axios");
+const { parseGitRemotes } = require("./utils");
+const path = require("upath");
+const fs = require("fs");
+const projectDir = process.cwd();
+const envPath = path.join(projectDir, ".env");
+// Load the .env file using dotenv
+if (fs.existsSync(envPath)) {
+    require("dotenv").config({ path: envPath });
+}
+else {
+    console.warn(`.env file not found at ${envPath}`);
+}
+// delete caches leaving single last cache based on creation date
+const ACCESS_TOKEN = process.env.ACCESS_TOKEN || process.env.GITHUB_TOKEN;
+if (!ACCESS_TOKEN) {
+    throw new Error("Access token is not provided. Please set ACCESS_TOKEN or GITHUB_TOKEN in your environment variables.");
+}
+/**
+ * Deletes a GitHub Actions cache.
+ * @param {string} GH_REPO - The GitHub repository in the format "owner/repo".
+ * @param {string} cacheId - The ID of the cache to delete.
+ * @returns {Promise} - A promise that resolves on success and rejects on error.
+ */
+function deleteGitHubActionsCache(GH_REPO, cacheId) {
+    return new Promise((resolve, reject) => {
+        const url = `https://api.github.com/repos/${GH_REPO}/actions/caches/${cacheId}`;
+        const token = ACCESS_TOKEN;
+        if (!token) {
+            return reject(new Error("Access token is not provided"));
+        }
+        axios
+            .delete(url, {
+            headers: {
+                Authorization: `token ${token}`,
+                Accept: "application/vnd.github.v3+json"
+            }
+        })
+            .then((response) => {
+            console.log(`Cache (${cacheId}) deleted successfully`, response.data);
+            resolve(response.data); // Resolve with the response data
+        })
+            .catch((error) => {
+            var _a;
+            console.error("Error deleting cache:", ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data) || error.message || "Unknown error");
+            reject(error); // Reject with the error
+        });
+    });
+}
+/**
+ * list github actions caches
+ * @param {string} GH_REPO
+ * @returns {Promise<Record<string, Record<string, any>[]>>}
+ */
+function get_caches(GH_REPO) {
+    const url = `https://api.github.com/repos/${GH_REPO}/actions/caches`;
+    return new Promise((resolve, reject) => {
+        axios
+            .get(url, {
+            headers: {
+                Accept: "application/vnd.github.v3+json",
+                Authorization: `token ${ACCESS_TOKEN}`
+            }
+        })
+            .then((response) => {
+            /**
+             * @type {Record<string, any>[]}
+             */
+            const data = response.data.actions_caches;
+            // resolve(response.data);
+            /**
+             * extract the prefix from the key
+             * @param {string} key
+             * @returns
+             */
+            const getPrefix = (key) => {
+                const split = key.split(/[-_]/);
+                if (split.length == 3) {
+                    return `${split[0]}-${split[1]}`;
+                }
+                else if (split.length > 3) {
+                    return `${split[0]}-${split[1]}-${split[2]}`;
+                }
+                return split[0];
+            };
+            // Group by prefix
+            const grouped = data.reduce(
+            /**
+             * @param {Record<string, Record<string, any>[]>} acc
+             * @param {Record<string, any>} item
+             * @returns {Record<string, Record<string, any>[]>}
+             */
+            (acc, item) => {
+                const prefix = getPrefix(item.key);
+                if (!acc[prefix]) {
+                    acc[prefix] = [];
+                }
+                acc[prefix].push(item);
+                return acc;
+            }, {});
+            // Convert the grouped object into an array of arrays
+            // const result = Object.values(grouped);
+            resolve(grouped);
+        })
+            .catch((error) => {
+            console.error("Error fetching data:", error);
+            reject(error); // Reject the promise with the error
+        });
+    });
+}
+/**
+ * Deletes old GitHub Actions caches for the current repository (origin remote),
+ * keeping only the most recent cache for each prefix (based on creation date).
+ * Retrieves caches, groups by prefix, sorts by creation date, and deletes all but the latest.
+ */
+(() => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const remotes = yield parseGitRemotes();
+        const GH_REPO = remotes.origin;
+        const caches = yield get_caches(GH_REPO);
+        for (const key in caches) {
+            if (Object.hasOwnProperty.call(caches, key)) {
+                const items = caches[key]
+                    .sort((a, b) => new Date(b.created_at) - new Date(a.created_at))
+                    .map((item) => (Object.assign(Object.assign({}, item), { human_readable_date: new Date(item.created_at).toLocaleString() })));
+                if (items.length > 1) {
+                    const ids = items.map((o) => o.id);
+                    ids.shift(); // keep the most recent cache
+                    if (ids.length > 0) {
+                        for (const id of ids) {
+                            try {
+                                yield deleteGitHubActionsCache(GH_REPO, id);
+                            }
+                            catch (err) {
+                                console.error(`Error deleting cache ${id}:`, err);
+                            }
+                        }
+                    }
+                    else {
+                        console.log(`cache prefix ${key} no cache left`);
+                    }
+                }
+                else {
+                    console.log(`cache prefix ${key} only have 1 cache`);
+                }
+            }
+        }
+    }
+    catch (e) {
+        console.error(`Error: ${e}`);
+    }
+}))();

package/lib/clean-github-actions-caches.d.cts

@@ -0,0 +1 @@
+export {};

package/lib/clean-github-actions-caches.d.mts

@@ -0,0 +1,169 @@
+const axios = require("axios");
+const { parseGitRemotes } = require("./utils");
+const path = require("upath");
+const fs = require("fs");
+const projectDir = process.cwd();
+const envPath = path.join(projectDir, ".env");
+
+// Load the .env file using dotenv
+if (fs.existsSync(envPath)) {
+  require("dotenv").config({ path: envPath });
+} else {
+  console.warn(`.env file not found at ${envPath}`);
+}
+
+// delete caches leaving single last cache based on creation date
+
+const ACCESS_TOKEN = process.env.ACCESS_TOKEN || process.env.GITHUB_TOKEN;
+
+if (!ACCESS_TOKEN) {
+  throw new Error(
+    "Access token is not provided. Please set ACCESS_TOKEN or GITHUB_TOKEN in your environment variables."
+  );
+}
+
+/**
+ * Deletes a GitHub Actions cache.
+ * @param {string} GH_REPO - The GitHub repository in the format "owner/repo".
+ * @param {string} cacheId - The ID of the cache to delete.
+ * @returns {Promise} - A promise that resolves on success and rejects on error.
+ */
+function deleteGitHubActionsCache(GH_REPO, cacheId) {
+  return new Promise((resolve, reject) => {
+    const url = `https://api.github.com/repos/${GH_REPO}/actions/caches/${cacheId}`;
+    const token = ACCESS_TOKEN;
+
+    if (!token) {
+      return reject(new Error("Access token is not provided"));
+    }
+
+    axios
+      .delete(url, {
+        headers: {
+          Authorization: `token ${token}`,
+          Accept: "application/vnd.github.v3+json"
+        }
+      })
+      .then((response) => {
+        console.log(`Cache (${cacheId}) deleted successfully`, response.data);
+        resolve(response.data); // Resolve with the response data
+      })
+      .catch((error) => {
+        console.error("Error deleting cache:", error.response?.data || error.message || "Unknown error");
+        reject(error); // Reject with the error
+      });
+  });
+}
+
+/**
+ * list github actions caches
+ * @param {string} GH_REPO
+ * @returns {Promise<Record<string, Record<string, any>[]>>}
+ */
+function get_caches(GH_REPO) {
+  const url = `https://api.github.com/repos/${GH_REPO}/actions/caches`;
+
+  return new Promise((resolve, reject) => {
+    axios
+      .get(url, {
+        headers: {
+          Accept: "application/vnd.github.v3+json",
+          Authorization: `token ${ACCESS_TOKEN}`
+        }
+      })
+      .then((response) => {
+        /**
+         * @type {Record<string, any>[]}
+         */
+        const data = response.data.actions_caches;
+        // resolve(response.data);
+        /**
+         * extract the prefix from the key
+         * @param {string} key
+         * @returns
+         */
+        const getPrefix = (key) => {
+          const split = key.split(/[-_]/);
+          if (split.length == 3) {
+            return `${split[0]}-${split[1]}`;
+          } else if (split.length > 3) {
+            return `${split[0]}-${split[1]}-${split[2]}`;
+          }
+          return split[0];
+        };
+
+        // Group by prefix
+        const grouped = data.reduce(
+          /**
+           * @param {Record<string, Record<string, any>[]>} acc
+           * @param {Record<string, any>} item
+           * @returns {Record<string, Record<string, any>[]>}
+           */
+          (acc, item) => {
+            const prefix = getPrefix(item.key);
+
+            if (!acc[prefix]) {
+              acc[prefix] = [];
+            }
+
+            acc[prefix].push(item);
+
+            return acc;
+          },
+          {}
+        );
+
+        // Convert the grouped object into an array of arrays
+        // const result = Object.values(grouped);
+        resolve(grouped);
+      })
+      .catch((error) => {
+        console.error("Error fetching data:", error);
+        reject(error); // Reject the promise with the error
+      });
+  });
+}
+
+/**
+ * Deletes old GitHub Actions caches for the current repository (origin remote),
+ * keeping only the most recent cache for each prefix (based on creation date).
+ * Retrieves caches, groups by prefix, sorts by creation date, and deletes all but the latest.
+ */
+(async () => {
+  try {
+    const remotes = await parseGitRemotes();
+    const GH_REPO = remotes.origin;
+    const caches = await get_caches(GH_REPO);
+
+    for (const key in caches) {
+      if (Object.hasOwnProperty.call(caches, key)) {
+        const items = caches[key]
+          .sort((a, b) => new Date(b.created_at) - new Date(a.created_at))
+          .map((item) => ({
+            ...item,
+            human_readable_date: new Date(item.created_at).toLocaleString()
+          }));
+
+        if (items.length > 1) {
+          const ids = items.map((o) => o.id);
+          ids.shift(); // keep the most recent cache
+          if (ids.length > 0) {
+            for (const id of ids) {
+              try {
+                await deleteGitHubActionsCache(GH_REPO, id);
+              } catch (err) {
+                console.error(`Error deleting cache ${id}:`, err);
+              }
+            }
+          } else {
+            console.log(`cache prefix ${key} no cache left`);
+          }
+        } else {
+          console.log(`cache prefix ${key} only have 1 cache`);
+        }
+      }
+    }
+  } catch (e) {
+    console.error(`Error: ${e}`);
+  }
+})();

package/lib/clean-github-actions-caches.d.ts

@@ -0,0 +1,169 @@
+const axios = require("axios");
+const { parseGitRemotes } = require("./utils");
+const path = require("upath");
+const fs = require("fs");
+const projectDir = process.cwd();
+const envPath = path.join(projectDir, ".env");
+
+// Load the .env file using dotenv
+if (fs.existsSync(envPath)) {
+  require("dotenv").config({ path: envPath });
+} else {
+  console.warn(`.env file not found at ${envPath}`);
+}
+
+// delete caches leaving single last cache based on creation date
+
+const ACCESS_TOKEN = process.env.ACCESS_TOKEN || process.env.GITHUB_TOKEN;
+
+if (!ACCESS_TOKEN) {
+  throw new Error(
+    "Access token is not provided. Please set ACCESS_TOKEN or GITHUB_TOKEN in your environment variables."
+  );
+}
+
+/**
+ * Deletes a GitHub Actions cache.
+ * @param {string} GH_REPO - The GitHub repository in the format "owner/repo".
+ * @param {string} cacheId - The ID of the cache to delete.
+ * @returns {Promise} - A promise that resolves on success and rejects on error.
+ */
+function deleteGitHubActionsCache(GH_REPO, cacheId) {
+  return new Promise((resolve, reject) => {
+    const url = `https://api.github.com/repos/${GH_REPO}/actions/caches/${cacheId}`;
+    const token = ACCESS_TOKEN;
+
+    if (!token) {
+      return reject(new Error("Access token is not provided"));
+    }
+
+    axios
+      .delete(url, {
+        headers: {
+          Authorization: `token ${token}`,
+          Accept: "application/vnd.github.v3+json"
+        }
+      })
+      .then((response) => {
+        console.log(`Cache (${cacheId}) deleted successfully`, response.data);
+        resolve(response.data); // Resolve with the response data
+      })
+      .catch((error) => {
+        console.error("Error deleting cache:", error.response?.data || error.message || "Unknown error");
+        reject(error); // Reject with the error
+      });
+  });
+}
+
+/**
+ * list github actions caches
+ * @param {string} GH_REPO
+ * @returns {Promise<Record<string, Record<string, any>[]>>}
+ */
+function get_caches(GH_REPO) {
+  const url = `https://api.github.com/repos/${GH_REPO}/actions/caches`;
+
+  return new Promise((resolve, reject) => {
+    axios
+      .get(url, {
+        headers: {
+          Accept: "application/vnd.github.v3+json",
+          Authorization: `token ${ACCESS_TOKEN}`
+        }
+      })
+      .then((response) => {
+        /**
+         * @type {Record<string, any>[]}
+         */
+        const data = response.data.actions_caches;
+        // resolve(response.data);
+        /**
+         * extract the prefix from the key
+         * @param {string} key
+         * @returns
+         */
+        const getPrefix = (key) => {
+          const split = key.split(/[-_]/);
+          if (split.length == 3) {
+            return `${split[0]}-${split[1]}`;
+          } else if (split.length > 3) {
+            return `${split[0]}-${split[1]}-${split[2]}`;
+          }
+          return split[0];
+        };
+
+        // Group by prefix
+        const grouped = data.reduce(
+          /**
+           * @param {Record<string, Record<string, any>[]>} acc
+           * @param {Record<string, any>} item
+           * @returns {Record<string, Record<string, any>[]>}
+           */
+          (acc, item) => {
+            const prefix = getPrefix(item.key);
+
+            if (!acc[prefix]) {
+              acc[prefix] = [];
+            }
+
+            acc[prefix].push(item);
+
+            return acc;
+          },
+          {}
+        );
+
+        // Convert the grouped object into an array of arrays
+        // const result = Object.values(grouped);
+        resolve(grouped);
+      })
+      .catch((error) => {
+        console.error("Error fetching data:", error);
+        reject(error); // Reject the promise with the error
+      });
+  });
+}
+
+/**
+ * Deletes old GitHub Actions caches for the current repository (origin remote),
+ * keeping only the most recent cache for each prefix (based on creation date).
+ * Retrieves caches, groups by prefix, sorts by creation date, and deletes all but the latest.
+ */
+(async () => {
+  try {
+    const remotes = await parseGitRemotes();
+    const GH_REPO = remotes.origin;
+    const caches = await get_caches(GH_REPO);
+
+    for (const key in caches) {
+      if (Object.hasOwnProperty.call(caches, key)) {
+        const items = caches[key]
+          .sort((a, b) => new Date(b.created_at) - new Date(a.created_at))
+          .map((item) => ({
+            ...item,
+            human_readable_date: new Date(item.created_at).toLocaleString()
+          }));
+
+        if (items.length > 1) {
+          const ids = items.map((o) => o.id);
+          ids.shift(); // keep the most recent cache
+          if (ids.length > 0) {
+            for (const id of ids) {
+              try {
+                await deleteGitHubActionsCache(GH_REPO, id);
+              } catch (err) {
+                console.error(`Error deleting cache ${id}:`, err);
+              }
+            }
+          } else {
+            console.log(`cache prefix ${key} no cache left`);
+          }
+        } else {
+          console.log(`cache prefix ${key} only have 1 cache`);
+        }
+      }
+    }
+  } catch (e) {
+    console.error(`Error: ${e}`);
+  }
+})();