binary-collections 2.0.12 → 2.0.14

package/lib/run-by-checksum/hash.cjs

@@ -0,0 +1,88 @@
+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/run-by-checksum/hash.js
+var hash_exports = {};
+__export(hash_exports, {
+  buildChecksum: () => buildChecksum,
+  getAllFiles: () => getAllFiles
+});
+module.exports = __toCommonJS(hash_exports);
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+var glob = __toESM(require("glob"), 1);
+var import_upath = __toESM(require("upath"), 1);
+var import_upath2 = __toESM(require("upath"), 1);
+var import_crypto = __toESM(require("crypto"), 1);
+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(import_upath.default.normalize(import_upath2.default.resolve(root, f)));
+    }
+  }
+  return [...files].sort();
+}
+function isBinaryFile(filePath, bytesToCheck = 8e3) {
+  const buffer = import_fs_extra.default.readFileSync(filePath, { length: bytesToCheck });
+  for (let i = 0; i < buffer.length; i++) {
+    if (buffer[i] === 0) {
+      return true;
+    }
+  }
+  return false;
+}
+function hashFile(file) {
+  const isBin = isBinaryFile(file);
+  if (!isBin) {
+    const content = import_fs_extra.default.readFileSync(file, { encoding: "utf-8" });
+    const normalized = content.toString().replace(/\s+/g, " ").trim();
+    return import_crypto.default.createHash("sha256").update(normalized).digest("hex");
+  } else {
+    const stats = import_fs_extra.default.statSync(file);
+    return import_crypto.default.createHash("sha256").update(file).update(String(stats.size)).digest("hex");
+  }
+}
+function buildChecksum(files) {
+  const hash = import_crypto.default.createHash("sha256");
+  for (const file of files) {
+    hash.update(file);
+    hash.update(hashFile(file));
+  }
+  return hash.digest("hex");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildChecksum,
+  getAllFiles
+});

package/lib/run-by-checksum/hash.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Get all files matching the given glob patterns, ignoring specified paths.
+ * @param {{ patterns: string[], ignore: string[], cwd?: string }} options
+ * @returns {string[]}
+ */
+export function getAllFiles({ patterns, ignore, cwd }: {
+    patterns: string[];
+    ignore: string[];
+    cwd?: string;
+}): string[];
+/**
+ * Build a combined SHA-256 checksum from an ordered list of files.
+ * For each file, both its path and content hash are fed into the digest.
+ * @param {string[]} files - Ordered list of absolute file paths
+ * @returns {string}
+ */
+export function buildChecksum(files: string[]): string;

package/lib/run-by-checksum/hash.js

@@ -0,0 +1,119 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllFiles = getAllFiles;
+exports.buildChecksum = buildChecksum;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const glob = __importStar(require("glob"));
+const upath_1 = __importDefault(require("upath"));
+const upath_2 = __importDefault(require("upath"));
+const crypto_1 = __importDefault(require("crypto"));
+/**
+ * Get all files matching the given glob patterns, ignoring specified paths.
+ * @param {{ patterns: string[], ignore: string[], cwd?: string }} options
+ * @returns {string[]}
+ */
+function getAllFiles({ patterns, ignore, cwd }) {
+    const files = 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) {
+            // Resolve to absolute path for consistent hashing
+            files.add(upath_1.default.normalize(upath_2.default.resolve(root, f)));
+        }
+    }
+    return [...files].sort();
+}
+/**
+ * Check if a file is binary by scanning for null bytes in the first N bytes.
+ * @param {string} filePath - Absolute path to the file
+ * @param {number} [bytesToCheck=8000] - Number of bytes to scan from the start
+ * @returns {boolean}
+ */
+function isBinaryFile(filePath, bytesToCheck = 8000) {
+    const buffer = fs_extra_1.default.readFileSync(filePath, { length: bytesToCheck });
+    for (let i = 0; i < buffer.length; i++) {
+        if (buffer[i] === 0) {
+            // Null byte is a strong indicator of binary
+            return true;
+        }
+    }
+    // Optionally, check if it decodes as UTF-8
+    return false;
+}
+/**
+ * Compute a SHA-256 hex digest for a file. For text files, the content is
+ * normalized (whitespace collapsed) before hashing. For binary files, the path
+ * and size are hashed instead of content.
+ * @private
+ * @param {string} file - Absolute path to the file
+ * @returns {string}
+ */
+function hashFile(file) {
+    const isBin = isBinaryFile(file);
+    if (!isBin) {
+        const content = fs_extra_1.default.readFileSync(file, { encoding: 'utf-8' });
+        // remove whitespaces and newlines for text files to avoid irrelevant changes affecting the checksum
+        const normalized = content.toString().replace(/\s+/g, ' ').trim();
+        return crypto_1.default.createHash('sha256').update(normalized).digest('hex');
+    }
+    else {
+        // For binary files, hash the file path and size instead of content
+        const stats = fs_extra_1.default.statSync(file);
+        return crypto_1.default.createHash('sha256').update(file).update(String(stats.size)).digest('hex');
+    }
+}
+/**
+ * Build a combined SHA-256 checksum from an ordered list of files.
+ * For each file, both its path and content hash are fed into the digest.
+ * @param {string[]} files - Ordered list of absolute file paths
+ * @returns {string}
+ */
+function buildChecksum(files) {
+    const hash = crypto_1.default.createHash('sha256');
+    for (const file of files) {
+        hash.update(file);
+        hash.update(hashFile(file));
+    }
+    return hash.digest('hex');
+}

package/lib/run-by-checksum/hash.mjs

@@ -0,0 +1,10 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  buildChecksum,
+  getAllFiles
+} from "../chunk-MCCMMZSM.mjs";
+import "../chunk-QQ4A6DLD.mjs";
+export {
+  buildChecksum,
+  getAllFiles
+};

package/lib/run-by-checksum/run.cjs

@@ -0,0 +1,185 @@
+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/run-by-checksum/run.js
+var run_exports = {};
+__export(run_exports, {
+  runChecksum: () => runChecksum
+});
+module.exports = __toCommonJS(run_exports);
+
+// src/run-by-checksum/hash.js
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+var glob = __toESM(require("glob"), 1);
+var import_upath = __toESM(require("upath"), 1);
+var import_upath2 = __toESM(require("upath"), 1);
+var import_crypto = __toESM(require("crypto"), 1);
+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(import_upath.default.normalize(import_upath2.default.resolve(root, f)));
+    }
+  }
+  return [...files].sort();
+}
+function isBinaryFile(filePath, bytesToCheck = 8e3) {
+  const buffer = import_fs_extra.default.readFileSync(filePath, { length: bytesToCheck });
+  for (let i = 0; i < buffer.length; i++) {
+    if (buffer[i] === 0) {
+      return true;
+    }
+  }
+  return false;
+}
+function hashFile(file) {
+  const isBin = isBinaryFile(file);
+  if (!isBin) {
+    const content = import_fs_extra.default.readFileSync(file, { encoding: "utf-8" });
+    const normalized = content.toString().replace(/\s+/g, " ").trim();
+    return import_crypto.default.createHash("sha256").update(normalized).digest("hex");
+  } else {
+    const stats = import_fs_extra.default.statSync(file);
+    return import_crypto.default.createHash("sha256").update(file).update(String(stats.size)).digest("hex");
+  }
+}
+function buildChecksum(files) {
+  const hash = import_crypto.default.createHash("sha256");
+  for (const file of files) {
+    hash.update(file);
+    hash.update(hashFile(file));
+  }
+  return hash.digest("hex");
+}
+
+// src/run-by-checksum/cache.js
+var import_fs_extra2 = __toESM(require("fs-extra"), 1);
+var import_upath3 = __toESM(require("upath"), 1);
+var import_crypto2 = __toESM(require("crypto"), 1);
+function md5(str) {
+  return import_crypto2.default.createHash("md5").update(str).digest("hex");
+}
+function getCacheFile({ patterns, ignore, cwd }) {
+  const root = cwd || process.env.INIT_CWD || process.cwd();
+  const key = md5(
+    JSON.stringify({
+      patterns: [...patterns].sort(),
+      ignore: [...ignore].sort()
+    })
+  );
+  return import_upath3.default.join(root, "tmp", ".checksum", `${key}.json`);
+}
+function loadCache(file) {
+  try {
+    return import_fs_extra2.default.readJsonSync(file);
+  } catch {
+    return null;
+  }
+}
+function saveCache(file, data) {
+  import_fs_extra2.default.ensureDirSync(import_upath3.default.dirname(file));
+  import_fs_extra2.default.writeJsonSync(file, data, { spaces: 2 });
+}
+
+// src/run-by-checksum/run.js
+var import_child_process = require("child_process");
+async function runChecksum({
+  patterns = [],
+  ignore = [],
+  exec,
+  cwd = process.env.INIT_CWD || process.cwd(),
+  dryRun = false
+}) {
+  if (!patterns.length && !exec) {
+    console.log("No patterns or command provided, skipping checksum runner.");
+    process.exit(1);
+  }
+  if (!exec) {
+    console.log("No command provided, skipping checksum runner.");
+    process.exit(1);
+  }
+  if (!patterns.length) {
+    console.log("No patterns provided, skipping checksum runner.");
+    process.exit(1);
+  }
+  const files = getAllFiles({ patterns, ignore, cwd });
+  const checksum = buildChecksum(files);
+  const cacheFile = getCacheFile({ patterns, ignore, cwd });
+  const cache = loadCache(cacheFile);
+  if ((cache == null ? void 0 : cache.checksum) === checksum) {
+    return {
+      changed: false,
+      cacheFile,
+      files
+    };
+  }
+  if (dryRun) {
+    return {
+      changed: true,
+      cacheFile,
+      files,
+      skipped: true
+    };
+  }
+  await runCommand(exec, cwd);
+  saveCache(cacheFile, {
+    checksum,
+    files,
+    patterns,
+    ignore,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  return {
+    changed: true,
+    cacheFile,
+    files
+  };
+}
+function runCommand(command, cwd) {
+  return new Promise((resolve, reject) => {
+    const child = (0, import_child_process.spawn)(command, {
+      shell: true,
+      stdio: "inherit",
+      cwd
+    });
+    child.on("exit", (code) => {
+      if (code === 0 || code === null) resolve();
+      else reject(new Error(`Command failed: ${code}`));
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runChecksum
+});

package/lib/run-by-checksum/run.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @param {{
+ *   patterns: string[],
+ *   ignore?: string[],
+ *   exec: string,
+ *   cwd?: string,
+ *   dryRun?: boolean
+ * }} options
+ * @returns {Promise<{ changed: boolean, cacheFile: string, files: string[], skipped?: boolean }>}
+ */
+export function runChecksum({ patterns, ignore, exec, cwd, dryRun }: {
+    patterns: string[];
+    ignore?: string[];
+    exec: string;
+    cwd?: string;
+    dryRun?: boolean;
+}): Promise<{
+    changed: boolean;
+    cacheFile: string;
+    files: string[];
+    skipped?: boolean;
+}>;

package/lib/run-by-checksum/run.js

@@ -0,0 +1,93 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runChecksum = runChecksum;
+const hash_js_1 = require("./hash.js");
+const cache_js_1 = require("./cache.js");
+const child_process_1 = require("child_process");
+/**
+ * @param {{
+ *   patterns: string[],
+ *   ignore?: string[],
+ *   exec: string,
+ *   cwd?: string,
+ *   dryRun?: boolean
+ * }} options
+ * @returns {Promise<{ changed: boolean, cacheFile: string, files: string[], skipped?: boolean }>}
+ */
+function runChecksum(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ patterns = [], ignore = [], exec, cwd = process.env.INIT_CWD || process.cwd(), dryRun = false }) {
+        if (!patterns.length && !exec) {
+            console.log('No patterns or command provided, skipping checksum runner.');
+            process.exit(1);
+        }
+        if (!exec) {
+            console.log('No command provided, skipping checksum runner.');
+            process.exit(1);
+        }
+        if (!patterns.length) {
+            console.log('No patterns provided, skipping checksum runner.');
+            process.exit(1);
+        }
+        const files = (0, hash_js_1.getAllFiles)({ patterns, ignore, cwd });
+        const checksum = (0, hash_js_1.buildChecksum)(files);
+        const cacheFile = (0, cache_js_1.getCacheFile)({ patterns, ignore, cwd });
+        const cache = (0, cache_js_1.loadCache)(cacheFile);
+        if ((cache === null || cache === void 0 ? void 0 : cache.checksum) === checksum) {
+            return {
+                changed: false,
+                cacheFile,
+                files
+            };
+        }
+        if (dryRun) {
+            return {
+                changed: true,
+                cacheFile,
+                files,
+                skipped: true
+            };
+        }
+        yield runCommand(exec, cwd);
+        (0, cache_js_1.saveCache)(cacheFile, {
+            checksum,
+            files,
+            patterns,
+            ignore,
+            updatedAt: new Date().toISOString()
+        });
+        return {
+            changed: true,
+            cacheFile,
+            files
+        };
+    });
+}
+/**
+ * @param {string} command
+ * @param {string} [cwd]
+ * @returns {Promise<void>}
+ */
+function runCommand(command, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(command, {
+            shell: true,
+            stdio: 'inherit',
+            cwd
+        });
+        child.on('exit', (code) => {
+            if (code === 0 || code === null)
+                resolve();
+            else
+                reject(new Error(`Command failed: ${code}`));
+        });
+    });
+}

package/lib/run-by-checksum/run.mjs

@@ -0,0 +1,10 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  runChecksum
+} from "../chunk-YLV4QATP.mjs";
+import "../chunk-QD4T255Z.mjs";
+import "../chunk-MCCMMZSM.mjs";
+import "../chunk-QQ4A6DLD.mjs";
+export {
+  runChecksum
+};