@effect/platform-node 0.28.3 → 0.28.4

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

@@ -1,435 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var Effectify = require('@effect/platform/Effectify');
-var Error = require('@effect/platform/Error');
-var FileSystem = require('@effect/platform/FileSystem');
-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-e477c10b.cjs.dev.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;
-
-Object.defineProperty(exports, 'FileSystem', {
-  enumerable: true,
-  get: function () { return FileSystem.FileSystem; }
-});
-Object.defineProperty(exports, 'Size', {
-  enumerable: true,
-  get: function () { return FileSystem.Size; }
-});
-exports.layer = layer;

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

@@ -1,7 +0,0 @@
-'use strict';
-
-if (process.env.NODE_ENV === "production") {
-  module.exports = require("./effect-platform-node-FileSystem.cjs.prod.js");
-} else {
-  module.exports = require("./effect-platform-node-FileSystem.cjs.dev.js");
-}

package/FileSystem/dist/effect-platform-node-FileSystem.cjs.mjs

@@ -1,5 +0,0 @@
-export {
-  FileSystem,
-  Size,
-  layer
-} from "./effect-platform-node-FileSystem.cjs.js";