@iowarp/clio-coder 0.3.0

package/dist/chunk-VPAWTYLY.js

@@ -0,0 +1,117 @@
+// src/core/safe-resource-write.ts
+import { randomBytes } from "node:crypto";
+import {
+  closeSync,
+  copyFileSync,
+  existsSync,
+  fsyncSync,
+  mkdirSync,
+  openSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeSync
+} from "node:fs";
+import path from "node:path";
+var resourceWriteSequence = 0;
+function safeResourceBackupPath(targetPath, suffix = ".bak") {
+  return `${targetPath}${suffix}`;
+}
+function fsyncDirectory(dir) {
+  let fd = null;
+  try {
+    fd = openSync(dir, "r");
+    fsyncSync(fd);
+  } catch {
+  } finally {
+    if (fd !== null) closeSync(fd);
+  }
+}
+function fsyncFile(filePath) {
+  const fd = openSync(filePath, "r");
+  try {
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+function tempPathFor(targetPath) {
+  const dir = path.dirname(targetPath);
+  const base = path.basename(targetPath);
+  const suffix = `${process.pid}-${Date.now()}-${++resourceWriteSequence}-${randomBytes(6).toString("hex")}`;
+  return path.join(dir, `.${base}.tmp-${suffix}`);
+}
+function writeMode(targetPath, mode) {
+  if (mode !== void 0) return mode;
+  try {
+    return statSync(targetPath).mode & 511;
+  } catch {
+    return 438;
+  }
+}
+function bufferFrom(contents, encoding) {
+  if (typeof contents === "string") return Buffer.from(contents, encoding ?? "utf8");
+  return Buffer.from(contents);
+}
+function writeAll(fd, buffer) {
+  let offset = 0;
+  while (offset < buffer.byteLength) {
+    offset += writeSync(fd, buffer, offset, buffer.byteLength - offset);
+  }
+}
+function backupOptions(backup) {
+  if (backup === true) return {};
+  if (!backup) return null;
+  return backup;
+}
+function safeResourceWrite(targetPath, contents, options = {}) {
+  const dir = path.dirname(targetPath);
+  mkdirSync(dir, { recursive: true });
+  const tempPath = tempPathFor(targetPath);
+  const buffer = bufferFrom(contents, options.encoding);
+  let tempExists = false;
+  let backupPath;
+  try {
+    const fd = openSync(tempPath, "wx", writeMode(targetPath, options.mode));
+    tempExists = true;
+    try {
+      writeAll(fd, buffer);
+      fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
+    const backup = backupOptions(options.backup);
+    if (backup && existsSync(targetPath)) {
+      backupPath = backup.path ?? safeResourceBackupPath(targetPath, backup.suffix ?? ".bak");
+      mkdirSync(path.dirname(backupPath), { recursive: true });
+      copyFileSync(targetPath, backupPath);
+      fsyncFile(backupPath);
+      fsyncDirectory(path.dirname(backupPath));
+    }
+    options.beforeRename?.({
+      targetPath,
+      tempPath,
+      bytes: buffer.byteLength,
+      ...backupPath ? { backupPath } : {}
+    });
+    renameSync(tempPath, targetPath);
+    tempExists = false;
+    fsyncDirectory(dir);
+    return {
+      path: targetPath,
+      tempPath,
+      bytes: buffer.byteLength,
+      ...backupPath ? { backupPath } : {}
+    };
+  } catch (err) {
+    if (tempExists) rmSync(tempPath, { force: true });
+    throw err;
+  }
+}
+
+export {
+  safeResourceBackupPath,
+  fsyncDirectory,
+  safeResourceWrite
+};
+//# sourceMappingURL=chunk-VPAWTYLY.js.map