@ricsam/r5d-worker 0.0.74 → 0.0.76

package/dist/cjs/working-tree-mirror.cjs

@@ -0,0 +1,225 @@
+"use strict";
+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);
+var working_tree_mirror_exports = {};
+__export(working_tree_mirror_exports, {
+  inspectWorkingTree: () => inspectWorkingTree,
+  mirrorWorkingTree: () => mirrorWorkingTree
+});
+module.exports = __toCommonJS(working_tree_mirror_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+function isGitMetadataPath(relativePath) {
+  return relativePath.split("/").includes(".git");
+}
+function normalizeRelativePath(value) {
+  const normalized = value.split(import_node_path.default.sep).join(import_node_path.default.posix.sep).replace(/^\.\/+/, "").replace(/^\/+|\/+$/g, "");
+  if (!normalized || normalized === "." || normalized.split("/").includes("..") || isGitMetadataPath(normalized)) return null;
+  return normalized;
+}
+function assertInside(root, candidate) {
+  const relative = import_node_path.default.relative(import_node_path.default.resolve(root), import_node_path.default.resolve(candidate));
+  if (relative === ".." || relative.startsWith(`..${import_node_path.default.sep}`) || import_node_path.default.isAbsolute(relative)) {
+    throw new Error(`Working-tree path escapes its root: ${candidate}`);
+  }
+}
+function gitEligibleRoots(root) {
+  const result = Bun.spawnSync(
+    [
+      "git",
+      "-c",
+      "submodule.recurse=false",
+      "-c",
+      "fetch.recurseSubmodules=false",
+      "-c",
+      "push.recurseSubmodules=false",
+      "ls-files",
+      "-z",
+      "--cached",
+      "--others",
+      "--exclude-standard",
+      "--",
+      "."
+    ],
+    {
+      cwd: root,
+      stdout: "pipe",
+      stderr: "pipe",
+      env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+    }
+  );
+  if (result.exitCode !== 0) {
+    throw new Error(`Inspect Git working tree: ${result.stderr.toString().trim() || `git exited ${result.exitCode}`}`);
+  }
+  return result.stdout.toString().split("\0").flatMap((entry) => {
+    const normalized = normalizeRelativePath(entry);
+    return normalized ? [normalized] : [];
+  }).sort();
+}
+function addEntry(entries, root, relativePath, recurseDirectories) {
+  const normalized = normalizeRelativePath(relativePath);
+  if (!normalized || entries.has(normalized)) return;
+  const absolutePath = import_node_path.default.join(root, ...normalized.split("/"));
+  assertInside(root, absolutePath);
+  let stat;
+  try {
+    stat = import_node_fs.default.lstatSync(absolutePath);
+  } catch (error) {
+    if (error.code === "ENOENT") return;
+    throw error;
+  }
+  if (stat.isSymbolicLink()) {
+    entries.set(normalized, { kind: "symlink", mode: stat.mode, target: import_node_fs.default.readlinkSync(absolutePath) });
+    return;
+  }
+  if (stat.isFile()) {
+    entries.set(normalized, { kind: "file", mode: stat.mode, size: stat.size });
+    return;
+  }
+  if (!stat.isDirectory()) return;
+  entries.set(normalized, { kind: "directory", mode: stat.mode });
+  if (!recurseDirectories) return;
+  for (const child of import_node_fs.default.readdirSync(absolutePath).sort()) {
+    addEntry(entries, root, import_node_path.default.posix.join(normalized, child), true);
+  }
+}
+function addParentDirectories(entries, root) {
+  for (const relativePath of [...entries.keys()]) {
+    let parent = import_node_path.default.posix.dirname(relativePath);
+    while (parent !== ".") {
+      if (!entries.has(parent)) {
+        const absolutePath = import_node_path.default.join(root, ...parent.split("/"));
+        const stat = import_node_fs.default.lstatSync(absolutePath);
+        entries.set(parent, { kind: "directory", mode: stat.mode });
+      }
+      parent = import_node_path.default.posix.dirname(parent);
+    }
+  }
+}
+function inspectWorkingTree(root, mode) {
+  const entries = /* @__PURE__ */ new Map();
+  if (!import_node_fs.default.existsSync(root)) return entries;
+  if (mode === "all") {
+    for (const child of import_node_fs.default.readdirSync(root).sort()) addEntry(entries, root, child, true);
+  } else {
+    for (const relativePath of gitEligibleRoots(root)) {
+      addEntry(entries, root, relativePath, true);
+    }
+  }
+  addParentDirectories(entries, root);
+  return entries;
+}
+function removeEntry(targetRoot, relativePath) {
+  const targetPath = import_node_path.default.join(targetRoot, ...relativePath.split("/"));
+  assertInside(targetRoot, targetPath);
+  import_node_fs.default.rmSync(targetPath, { recursive: true, force: true });
+}
+function ensureDirectory(targetRoot, relativePath, mode) {
+  const targetPath = import_node_path.default.join(targetRoot, ...relativePath.split("/"));
+  assertInside(targetRoot, targetPath);
+  if (import_node_fs.default.existsSync(targetPath) && !import_node_fs.default.lstatSync(targetPath).isDirectory()) removeEntry(targetRoot, relativePath);
+  import_node_fs.default.mkdirSync(targetPath, { recursive: true, mode: mode & 511 });
+}
+function filesEqual(leftPath, rightPath, size) {
+  let rightStat;
+  try {
+    rightStat = import_node_fs.default.lstatSync(rightPath);
+  } catch {
+    return false;
+  }
+  if (!rightStat.isFile() || rightStat.size !== size) return false;
+  const left = import_node_fs.default.openSync(leftPath, "r");
+  const right = import_node_fs.default.openSync(rightPath, "r");
+  const leftBuffer = Buffer.allocUnsafe(64 * 1024);
+  const rightBuffer = Buffer.allocUnsafe(64 * 1024);
+  try {
+    let offset = 0;
+    while (offset < size) {
+      const length = Math.min(leftBuffer.length, size - offset);
+      const leftRead = import_node_fs.default.readSync(left, leftBuffer, 0, length, offset);
+      const rightRead = import_node_fs.default.readSync(right, rightBuffer, 0, length, offset);
+      if (leftRead !== rightRead || !leftBuffer.subarray(0, leftRead).equals(rightBuffer.subarray(0, rightRead))) return false;
+      offset += leftRead;
+    }
+    return true;
+  } finally {
+    import_node_fs.default.closeSync(left);
+    import_node_fs.default.closeSync(right);
+  }
+}
+function copyEntry(sourceRoot, targetRoot, relativePath, entry) {
+  const sourcePath = import_node_path.default.join(sourceRoot, ...relativePath.split("/"));
+  const targetPath = import_node_path.default.join(targetRoot, ...relativePath.split("/"));
+  assertInside(sourceRoot, sourcePath);
+  assertInside(targetRoot, targetPath);
+  const parent = import_node_path.default.posix.dirname(relativePath);
+  if (parent !== ".") ensureDirectory(targetRoot, parent, 493);
+  if (entry.kind === "directory") {
+    ensureDirectory(targetRoot, relativePath, entry.mode);
+    return;
+  }
+  if (entry.kind === "symlink") {
+    let unchanged = false;
+    try {
+      unchanged = import_node_fs.default.lstatSync(targetPath).isSymbolicLink() && import_node_fs.default.readlinkSync(targetPath) === entry.target;
+    } catch {
+      unchanged = false;
+    }
+    if (!unchanged) {
+      removeEntry(targetRoot, relativePath);
+      import_node_fs.default.symlinkSync(entry.target, targetPath);
+    }
+    return;
+  }
+  if (!filesEqual(sourcePath, targetPath, entry.size)) {
+    if (import_node_fs.default.existsSync(targetPath) && !import_node_fs.default.lstatSync(targetPath).isFile()) removeEntry(targetRoot, relativePath);
+    import_node_fs.default.copyFileSync(sourcePath, targetPath);
+  }
+  import_node_fs.default.chmodSync(targetPath, entry.mode & 511);
+}
+function mirrorWorkingTree(input) {
+  const sourceRoot = import_node_path.default.resolve(input.sourceRoot);
+  const targetRoot = import_node_path.default.resolve(input.targetRoot);
+  import_node_fs.default.mkdirSync(targetRoot, { recursive: true });
+  const desired = inspectWorkingTree(sourceRoot, input.sourceMode);
+  const existing = inspectWorkingTree(targetRoot, input.deletionMode === "git" ? "git" : "all");
+  for (const relativePath of [...existing.keys()].sort((left, right) => right.split("/").length - left.split("/").length)) {
+    if (!desired.has(relativePath)) removeEntry(targetRoot, relativePath);
+  }
+  for (const [relativePath, entry] of [...desired.entries()].sort(
+    ([left], [right]) => left.split("/").length - right.split("/").length || left.localeCompare(right)
+  )) {
+    copyEntry(sourceRoot, targetRoot, relativePath, entry);
+  }
+  return { paths: [...desired.keys()].filter((relativePath) => desired.get(relativePath)?.kind !== "directory").sort() };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  inspectWorkingTree,
+  mirrorWorkingTree
+});