@effect/platform-node 0.19.9 → 0.20.1

package/FileSystem/dist/effect-platform-node-FileSystem.cjs.prod.js

@@ -2,28 +2,434 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var FileSystem_dist_effectPlatformNodeFileSystem = require('../../dist/FileSystem-a207377d.cjs.prod.js');
+var Effectify = require('@effect/platform/Effectify');
+var Error = require('@effect/platform/Error');
 var FileSystem = require('@effect/platform/FileSystem');
-require('@effect/platform/Effectify');
-require('@effect/platform/Error');
-require('effect/Effect');
-require('effect/Function');
-require('effect/Layer');
-require('effect/Option');
-require('node:crypto');
-require('node:fs');
-require('node:os');
-require('node:path');
-require('../../dist/error-4f074a3a.cjs.prod.js');
+var Effect = require('effect/Effect');
+var Function = require('effect/Function');
+var Layer = require('effect/Layer');
+var Option = require('effect/Option');
+var Crypto = require('node:crypto');
+var NFS = require('node:fs');
+var OS = require('node:os');
+var NodePath = require('node:path');
+var error = require('../../dist/error-4f074a3a.cjs.prod.js');
 
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
 
+var Error__namespace = /*#__PURE__*/_interopNamespace(Error);
+var FileSystem__namespace = /*#__PURE__*/_interopNamespace(FileSystem);
+var Effect__namespace = /*#__PURE__*/_interopNamespace(Effect);
+var Layer__namespace = /*#__PURE__*/_interopNamespace(Layer);
+var Option__namespace = /*#__PURE__*/_interopNamespace(Option);
+var Crypto__namespace = /*#__PURE__*/_interopNamespace(Crypto);
+var NFS__namespace = /*#__PURE__*/_interopNamespace(NFS);
+var OS__namespace = /*#__PURE__*/_interopNamespace(OS);
+var NodePath__namespace = /*#__PURE__*/_interopNamespace(NodePath);
+
+const handleBadArgument = method => err => Error__namespace.BadArgument({
+  module: "FileSystem",
+  method,
+  message: err.message ?? String(err)
+});
+
+// == access
+
+const access = /*#__PURE__*/(() => {
+  const nodeAccess = /*#__PURE__*/Effectify.effectify(NFS__namespace.access, /*#__PURE__*/error.handleErrnoException("FileSystem", "access"), /*#__PURE__*/handleBadArgument("access"));
+  return (path, options) => {
+    let mode = NFS__namespace.constants.F_OK;
+    if (options?.readable) {
+      mode |= NFS__namespace.constants.R_OK;
+    }
+    if (options?.writable) {
+      mode |= NFS__namespace.constants.W_OK;
+    }
+    return nodeAccess(path, mode);
+  };
+})();
+
+// == copy
+
+const copy = /*#__PURE__*/(() => {
+  const nodeCp = /*#__PURE__*/Effectify.effectify(NFS__namespace.cp, /*#__PURE__*/error.handleErrnoException("FileSystem", "copy"), /*#__PURE__*/handleBadArgument("copy"));
+  return (fromPath, toPath, options) => nodeCp(fromPath, toPath, {
+    force: options?.overwrite ?? false,
+    preserveTimestamps: options?.preserveTimestamps ?? false,
+    recursive: true
+  });
+})();
+
+// == copyFile
+
+const copyFile = /*#__PURE__*/(() => {
+  const nodeCopyFile = /*#__PURE__*/Effectify.effectify(NFS__namespace.copyFile, /*#__PURE__*/error.handleErrnoException("FileSystem", "copyFile"), /*#__PURE__*/handleBadArgument("copyFile"));
+  return (fromPath, toPath) => nodeCopyFile(fromPath, toPath);
+})();
+
+// == chmod
+
+const chmod = /*#__PURE__*/(() => {
+  const nodeChmod = /*#__PURE__*/Effectify.effectify(NFS__namespace.chmod, /*#__PURE__*/error.handleErrnoException("FileSystem", "chmod"), /*#__PURE__*/handleBadArgument("chmod"));
+  return (path, mode) => nodeChmod(path, mode);
+})();
+
+// == chown
+
+const chown = /*#__PURE__*/(() => {
+  const nodeChown = /*#__PURE__*/Effectify.effectify(NFS__namespace.chown, /*#__PURE__*/error.handleErrnoException("FileSystem", "chown"), /*#__PURE__*/handleBadArgument("chown"));
+  return (path, uid, gid) => nodeChown(path, uid, gid);
+})();
+
+// == link
+
+const link = /*#__PURE__*/(() => {
+  const nodeLink = /*#__PURE__*/Effectify.effectify(NFS__namespace.link, /*#__PURE__*/error.handleErrnoException("FileSystem", "link"), /*#__PURE__*/handleBadArgument("link"));
+  return (existingPath, newPath) => nodeLink(existingPath, newPath);
+})();
+
+// == makeDirectory
+
+const makeDirectory = /*#__PURE__*/(() => {
+  const nodeMkdir = /*#__PURE__*/Effectify.effectify(NFS__namespace.mkdir, /*#__PURE__*/error.handleErrnoException("FileSystem", "makeDirectory"), /*#__PURE__*/handleBadArgument("makeDirectory"));
+  return (path, options) => nodeMkdir(path, {
+    recursive: options?.recursive ?? false,
+    mode: options?.mode
+  });
+})();
+
+// == makeTempDirectory
+
+const makeTempDirectoryFactory = method => {
+  const nodeMkdtemp = Effectify.effectify(NFS__namespace.mkdtemp, error.handleErrnoException("FileSystem", method), handleBadArgument(method));
+  return options => Effect__namespace.suspend(() => {
+    const prefix = options?.prefix ?? "";
+    const directory = typeof options?.directory === "string" ? NodePath__namespace.join(options.directory, ".") : OS__namespace.tmpdir();
+    return nodeMkdtemp(prefix ? NodePath__namespace.join(directory, prefix) : directory + "/");
+  });
+};
+const makeTempDirectory = /*#__PURE__*/makeTempDirectoryFactory("makeTempDirectory");
+
+// == remove
+
+const removeFactory = method => {
+  const nodeRm = Effectify.effectify(NFS__namespace.rm, error.handleErrnoException("FileSystem", method), handleBadArgument(method));
+  return (path, options) => nodeRm(path, {
+    recursive: options?.recursive ?? false
+  });
+};
+const remove = /*#__PURE__*/removeFactory("remove");
+
+// == makeTempDirectoryScoped
+
+const makeTempDirectoryScoped = /*#__PURE__*/(() => {
+  const makeDirectory = /*#__PURE__*/makeTempDirectoryFactory("makeTempDirectoryScoped");
+  const removeDirectory = /*#__PURE__*/removeFactory("makeTempDirectoryScoped");
+  return options => Effect__namespace.acquireRelease(makeDirectory(options), directory => Effect__namespace.orDie(removeDirectory(directory, {
+    recursive: true
+  })));
+})();
+
+// == open
+
+const openFactory = method => {
+  const nodeOpen = Effectify.effectify(NFS__namespace.open, error.handleErrnoException("FileSystem", method), handleBadArgument(method));
+  const nodeClose = Effectify.effectify(NFS__namespace.close, error.handleErrnoException("FileSystem", method), handleBadArgument(method));
+  return (path, options) => Function.pipe(Effect__namespace.acquireRelease(nodeOpen(path, options?.flag ?? "r", options?.mode), fd => Effect__namespace.orDie(nodeClose(fd))), Effect__namespace.map(fd => makeFile(FileSystem__namespace.FileDescriptor(fd), options?.flag?.startsWith("a") ?? false)));
+};
+const open = /*#__PURE__*/openFactory("open");
+const makeFile = /*#__PURE__*/(() => {
+  const nodeReadFactory = method => Effectify.effectify(NFS__namespace.read, error.handleErrnoException("FileSystem", method), handleBadArgument(method));
+  const nodeRead = /*#__PURE__*/nodeReadFactory("read");
+  const nodeReadAlloc = /*#__PURE__*/nodeReadFactory("readAlloc");
+  const nodeStat = /*#__PURE__*/Effectify.effectify(NFS__namespace.fstat, /*#__PURE__*/error.handleErrnoException("FileSystem", "stat"), /*#__PURE__*/handleBadArgument("stat"));
+  const nodeTruncate = /*#__PURE__*/Effectify.effectify(NFS__namespace.ftruncate, /*#__PURE__*/error.handleErrnoException("FileSystem", "truncate"), /*#__PURE__*/handleBadArgument("truncate"));
+  const nodeWriteFactory = method => Effectify.effectify(NFS__namespace.write, error.handleErrnoException("FileSystem", method), handleBadArgument(method));
+  const nodeWrite = /*#__PURE__*/nodeWriteFactory("write");
+  const nodeWriteAll = /*#__PURE__*/nodeWriteFactory("writeAll");
+  class FileImpl {
+    semaphore = Effect__namespace.unsafeMakeSemaphore(1);
+    position = 0n;
+    constructor(fd, append) {
+      this.fd = fd;
+      this.append = append;
+      this[FileSystem__namespace.FileTypeId] = FileSystem__namespace.FileTypeId;
+    }
+    get stat() {
+      return Effect__namespace.map(nodeStat(this.fd), makeFileInfo);
+    }
+    seek(offset, from) {
+      const offsetSize = FileSystem__namespace.Size(offset);
+      return this.semaphore.withPermits(1)(Effect__namespace.sync(() => {
+        if (from === "start") {
+          this.position = offsetSize;
+        } else if (from === "current") {
+          this.position = this.position + offsetSize;
+        }
+        return this.position;
+      }));
+    }
+    read(buffer) {
+      return this.semaphore.withPermits(1)(Effect__namespace.map(Effect__namespace.suspend(() => nodeRead(this.fd, {
+        buffer,
+        position: this.position
+      })), bytesRead => {
+        const sizeRead = FileSystem__namespace.Size(bytesRead);
+        this.position = this.position + sizeRead;
+        return sizeRead;
+      }));
+    }
+    readAlloc(size) {
+      const sizeNumber = Number(size);
+      return this.semaphore.withPermits(1)(Effect__namespace.flatMap(Effect__namespace.sync(() => Buffer.allocUnsafeSlow(sizeNumber)), buffer => Effect__namespace.map(nodeReadAlloc(this.fd, {
+        buffer,
+        position: this.position
+      }), bytesRead => {
+        if (bytesRead === 0) {
+          return Option__namespace.none();
+        }
+        this.position = this.position + BigInt(bytesRead);
+        if (bytesRead === sizeNumber) {
+          return Option__namespace.some(buffer);
+        }
+        const dst = Buffer.allocUnsafeSlow(bytesRead);
+        buffer.copy(dst, 0, 0, bytesRead);
+        return Option__namespace.some(dst);
+      })));
+    }
+    truncate(length) {
+      return this.semaphore.withPermits(1)(Effect__namespace.map(nodeTruncate(this.fd, length ? Number(length) : undefined), () => {
+        if (!this.append) {
+          const len = BigInt(length ?? 0);
+          if (this.position > len) {
+            this.position = len;
+          }
+        }
+      }));
+    }
+    write(buffer) {
+      return this.semaphore.withPermits(1)(Effect__namespace.map(Effect__namespace.suspend(() => nodeWrite(this.fd, buffer, undefined, undefined, this.append ? undefined : Number(this.position))), bytesWritten => {
+        const sizeWritten = FileSystem__namespace.Size(bytesWritten);
+        if (!this.append) {
+          this.position = this.position + sizeWritten;
+        }
+        return sizeWritten;
+      }));
+    }
+    writeAllChunk(buffer) {
+      return Effect__namespace.flatMap(Effect__namespace.suspend(() => nodeWriteAll(this.fd, buffer, undefined, undefined, this.append ? undefined : Number(this.position))), bytesWritten => {
+        if (bytesWritten === 0) {
+          return Effect__namespace.fail(Error__namespace.SystemError({
+            module: "FileSystem",
+            method: "writeAll",
+            reason: "WriteZero",
+            pathOrDescriptor: this.fd,
+            message: "write returned 0 bytes written"
+          }));
+        }
+        if (!this.append) {
+          this.position = this.position + BigInt(bytesWritten);
+        }
+        return bytesWritten < buffer.length ? this.writeAllChunk(buffer.subarray(bytesWritten)) : Effect__namespace.unit;
+      });
+    }
+    writeAll(buffer) {
+      return this.semaphore.withPermits(1)(this.writeAllChunk(buffer));
+    }
+  }
+  return (fd, append) => new FileImpl(fd, append);
+})();
+
+// == makeTempFile
+
+const makeTempFileFactory = method => {
+  const makeDirectory = makeTempDirectoryFactory(method);
+  const open = openFactory(method);
+  const randomHexString = bytes => Effect__namespace.sync(() => Crypto__namespace.randomBytes(bytes).toString("hex"));
+  return options => Function.pipe(Effect__namespace.zip(makeDirectory(options), randomHexString(6)), Effect__namespace.map(([directory, random]) => NodePath__namespace.join(directory, random)), Effect__namespace.tap(path => Effect__namespace.scoped(open(path, {
+    flag: "w+"
+  }))));
+};
+const makeTempFile = /*#__PURE__*/makeTempFileFactory("makeTempFile");
+
+// == makeTempFileScoped
+
+const makeTempFileScoped = /*#__PURE__*/(() => {
+  const makeFile = /*#__PURE__*/makeTempFileFactory("makeTempFileScoped");
+  const removeFile = /*#__PURE__*/removeFactory("makeTempFileScoped");
+  return options => Effect__namespace.acquireRelease(makeFile(options), file => Effect__namespace.orDie(removeFile(file)));
+})();
+
+// == readDirectory
+
+const readDirectory = /*#__PURE__*/(() => {
+  const nodeReadDirectory = /*#__PURE__*/Effectify.effectify(NFS__namespace.readdir, /*#__PURE__*/error.handleErrnoException("FileSystem", "readDirectory"), /*#__PURE__*/handleBadArgument("readDirectory"));
+  return (path, options) => nodeReadDirectory(path, options);
+})();
+
+// == readFile
+
+const readFile = path => Effect__namespace.async((resume, signal) => {
+  try {
+    NFS__namespace.readFile(path, {
+      signal
+    }, (err, data) => {
+      if (err) {
+        resume(Effect__namespace.fail(error.handleErrnoException("FileSystem", "readFile")(err, [path])));
+      } else {
+        resume(Effect__namespace.succeed(data));
+      }
+    });
+  } catch (err) {
+    resume(Effect__namespace.fail(handleBadArgument("readFile")(err)));
+  }
+});
+
+// == readLink
+
+const readLink = /*#__PURE__*/(() => {
+  const nodeReadLink = /*#__PURE__*/Effectify.effectify(NFS__namespace.readlink, /*#__PURE__*/error.handleErrnoException("FileSystem", "readLink"), /*#__PURE__*/handleBadArgument("readLink"));
+  return path => nodeReadLink(path);
+})();
+
+// == realPath
+
+const realPath = /*#__PURE__*/(() => {
+  const nodeRealPath = /*#__PURE__*/Effectify.effectify(NFS__namespace.realpath, /*#__PURE__*/error.handleErrnoException("FileSystem", "realPath"), /*#__PURE__*/handleBadArgument("realPath"));
+  return path => nodeRealPath(path);
+})();
+
+// == rename
+
+const rename = /*#__PURE__*/(() => {
+  const nodeRename = /*#__PURE__*/Effectify.effectify(NFS__namespace.rename, /*#__PURE__*/error.handleErrnoException("FileSystem", "rename"), /*#__PURE__*/handleBadArgument("rename"));
+  return (oldPath, newPath) => nodeRename(oldPath, newPath);
+})();
+
+// == stat
+
+const makeFileInfo = stat => ({
+  type: stat.isFile() ? "File" : stat.isDirectory() ? "Directory" : stat.isSymbolicLink() ? "SymbolicLink" : stat.isBlockDevice() ? "BlockDevice" : stat.isCharacterDevice() ? "CharacterDevice" : stat.isFIFO() ? "FIFO" : stat.isSocket() ? "Socket" : "Unknown",
+  mtime: Option__namespace.fromNullable(stat.mtime),
+  atime: Option__namespace.fromNullable(stat.atime),
+  birthtime: Option__namespace.fromNullable(stat.birthtime),
+  dev: stat.dev,
+  rdev: Option__namespace.fromNullable(stat.rdev),
+  ino: Option__namespace.fromNullable(stat.ino),
+  mode: stat.mode,
+  nlink: Option__namespace.fromNullable(stat.nlink),
+  uid: Option__namespace.fromNullable(stat.uid),
+  gid: Option__namespace.fromNullable(stat.gid),
+  size: FileSystem__namespace.Size(stat.size),
+  blksize: Option__namespace.fromNullable(FileSystem__namespace.Size(stat.blksize)),
+  blocks: Option__namespace.fromNullable(stat.blocks)
+});
+const stat = /*#__PURE__*/(() => {
+  const nodeStat = /*#__PURE__*/Effectify.effectify(NFS__namespace.stat, /*#__PURE__*/error.handleErrnoException("FileSystem", "stat"), /*#__PURE__*/handleBadArgument("stat"));
+  return path => Effect__namespace.map(nodeStat(path), makeFileInfo);
+})();
+
+// == symlink
+
+const symlink = /*#__PURE__*/(() => {
+  const nodeSymlink = /*#__PURE__*/Effectify.effectify(NFS__namespace.symlink, /*#__PURE__*/error.handleErrnoException("FileSystem", "symlink"), /*#__PURE__*/handleBadArgument("symlink"));
+  return (target, path) => nodeSymlink(target, path);
+})();
+
+// == truncate
+
+const truncate = /*#__PURE__*/(() => {
+  const nodeTruncate = /*#__PURE__*/Effectify.effectify(NFS__namespace.truncate, /*#__PURE__*/error.handleErrnoException("FileSystem", "truncate"), /*#__PURE__*/handleBadArgument("truncate"));
+  return (path, length) => nodeTruncate(path, length !== undefined ? Number(length) : undefined);
+})();
+
+// == utimes
+
+const utimes = /*#__PURE__*/(() => {
+  const nodeUtimes = /*#__PURE__*/Effectify.effectify(NFS__namespace.utimes, /*#__PURE__*/error.handleErrnoException("FileSystem", "utime"), /*#__PURE__*/handleBadArgument("utime"));
+  return (path, atime, mtime) => nodeUtimes(path, atime, mtime);
+})();
+
+// == writeFile
+
+const writeFile = (path, data, options) => Effect__namespace.async((resume, signal) => {
+  try {
+    NFS__namespace.writeFile(path, data, {
+      signal,
+      flag: options?.flag,
+      mode: options?.mode
+    }, err => {
+      if (err) {
+        resume(Effect__namespace.fail(error.handleErrnoException("FileSystem", "writeFile")(err, [path])));
+      } else {
+        resume(Effect__namespace.unit);
+      }
+    });
+  } catch (err) {
+    resume(Effect__namespace.fail(handleBadArgument("writeFile")(err)));
+  }
+});
+const fileSystemImpl = /*#__PURE__*/FileSystem__namespace.make({
+  access,
+  chmod,
+  chown,
+  copy,
+  copyFile,
+  link,
+  makeDirectory,
+  makeTempDirectory,
+  makeTempDirectoryScoped,
+  makeTempFile,
+  makeTempFileScoped,
+  open,
+  readDirectory,
+  readFile,
+  readLink,
+  realPath,
+  remove,
+  rename,
+  stat,
+  symlink,
+  truncate,
+  utimes,
+  writeFile
+});
+
+/** @internal */
+const layer$1 = /*#__PURE__*/Layer__namespace.succeed(FileSystem__namespace.FileSystem, fileSystemImpl);
+
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ * @category layer
+ */
+const layer = layer$1;
 
-exports.layer = FileSystem_dist_effectPlatformNodeFileSystem.layer;
 Object.defineProperty(exports, 'FileSystem', {
-	enumerable: true,
-	get: function () { return FileSystem.FileSystem; }
+  enumerable: true,
+  get: function () { return FileSystem.FileSystem; }
 });
 Object.defineProperty(exports, 'Size', {
-	enumerable: true,
-	get: function () { return FileSystem.Size; }
+  enumerable: true,
+  get: function () { return FileSystem.Size; }
 });
+exports.layer = layer;