@effect/platform-node 0.19.2 → 0.19.4

package/dist/platform-d09ef04f.cjs.prod.js

@@ -0,0 +1,73 @@
+'use strict';
+
+var Platform = require('@effect/platform/Http/Platform');
+var ServerResponse = require('@effect/platform/Http/ServerResponse');
+var Function = require('effect/Function');
+var Layer = require('effect/Layer');
+var Mime = require('mime');
+var NFS = require('node:fs');
+var node_stream = require('node:stream');
+var FileSystem_dist_effectPlatformNodeFileSystem = require('./FileSystem-a207377d.cjs.prod.js');
+var Http_Etag_dist_effectPlatformNodeHttpEtag = require('./Etag-7a3db878.cjs.prod.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+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 Platform__namespace = /*#__PURE__*/_interopNamespace(Platform);
+var ServerResponse__namespace = /*#__PURE__*/_interopNamespace(ServerResponse);
+var Layer__namespace = /*#__PURE__*/_interopNamespace(Layer);
+var Mime__default = /*#__PURE__*/_interopDefault(Mime);
+var NFS__namespace = /*#__PURE__*/_interopNamespace(NFS);
+
+/** @internal */
+const make = /*#__PURE__*/Platform__namespace.make({
+  fileResponse(path, status, statusText, headers, start, end, contentLength) {
+    const stream = NFS__namespace.createReadStream(path, {
+      start,
+      end
+    });
+    return ServerResponse__namespace.raw(stream, {
+      headers: {
+        ...headers,
+        "content-type": headers["content-type"] ?? Mime__default["default"].getType(path) ?? "application/octet-stream",
+        "content-length": contentLength.toString()
+      },
+      status,
+      statusText
+    });
+  },
+  fileWebResponse(file, status, statusText, headers, _options) {
+    return ServerResponse__namespace.raw(node_stream.Readable.fromWeb(file.stream()), {
+      headers: {
+        ...headers,
+        "content-type": headers["content-type"] ?? Mime__default["default"].getType(file.name) ?? "application/octet-stream",
+        "content-length": file.size.toString()
+      },
+      status,
+      statusText
+    });
+  }
+});
+
+/** @internal */
+const layer = /*#__PURE__*/Function.pipe( /*#__PURE__*/Layer__namespace.effect(Platform__namespace.Platform, make), /*#__PURE__*/Layer__namespace.use(FileSystem_dist_effectPlatformNodeFileSystem.layer), /*#__PURE__*/Layer__namespace.use(Http_Etag_dist_effectPlatformNodeHttpEtag.layer));
+
+exports.layer = layer;
+exports.make = make;

package/dist/sink-da49e187.cjs.prod.js

@@ -0,0 +1,57 @@
+'use strict';
+
+var Effect = require('effect/Effect');
+var Function = require('effect/Function');
+var Sink = require('effect/Sink');
+
+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 Effect__namespace = /*#__PURE__*/_interopNamespace(Effect);
+var Sink__namespace = /*#__PURE__*/_interopNamespace(Sink);
+
+/** @internal */
+const fromWritable = (evaluate, onError, {
+  encoding,
+  endOnClose = true
+} = {}) => endOnClose ? makeSinkWithRelease(evaluate, onError, encoding) : makeSink(evaluate, onError, encoding);
+const makeSink = (stream, onError, encoding) => Function.pipe(Effect__namespace.sync(stream), Effect__namespace.map(stream => Sink__namespace.forEach(write(stream, onError, encoding))), Sink__namespace.unwrap);
+const makeSinkWithRelease = (stream, onError, encoding) => Function.pipe(Effect__namespace.acquireRelease(Effect__namespace.sync(stream), endWritable), Effect__namespace.map(stream => Sink__namespace.forEach(write(stream, onError, encoding))), Sink__namespace.unwrapScoped);
+const endWritable = stream => Effect__namespace.async(resume => {
+  if (stream.closed) {
+    resume(Effect__namespace.unit);
+    return;
+  }
+  stream.end(() => resume(Effect__namespace.unit));
+});
+const write = (stream, onError, encoding) => _ => Effect__namespace.async(resume => {
+  const cb = err => {
+    if (err) {
+      resume(Effect__namespace.fail(onError(err)));
+    } else {
+      resume(Effect__namespace.unit);
+    }
+  };
+  if (encoding) {
+    stream.write(_, encoding, cb);
+  } else {
+    stream.write(_, cb);
+  }
+});
+
+exports.fromWritable = fromWritable;

package/dist/sink-daf9e0e5.cjs.dev.js

@@ -0,0 +1,57 @@
+'use strict';
+
+var Effect = require('effect/Effect');
+var Function = require('effect/Function');
+var Sink = require('effect/Sink');
+
+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 Effect__namespace = /*#__PURE__*/_interopNamespace(Effect);
+var Sink__namespace = /*#__PURE__*/_interopNamespace(Sink);
+
+/** @internal */
+const fromWritable = (evaluate, onError, {
+  encoding,
+  endOnClose = true
+} = {}) => endOnClose ? makeSinkWithRelease(evaluate, onError, encoding) : makeSink(evaluate, onError, encoding);
+const makeSink = (stream, onError, encoding) => Function.pipe(Effect__namespace.sync(stream), Effect__namespace.map(stream => Sink__namespace.forEach(write(stream, onError, encoding))), Sink__namespace.unwrap);
+const makeSinkWithRelease = (stream, onError, encoding) => Function.pipe(Effect__namespace.acquireRelease(Effect__namespace.sync(stream), endWritable), Effect__namespace.map(stream => Sink__namespace.forEach(write(stream, onError, encoding))), Sink__namespace.unwrapScoped);
+const endWritable = stream => Effect__namespace.async(resume => {
+  if (stream.closed) {
+    resume(Effect__namespace.unit);
+    return;
+  }
+  stream.end(() => resume(Effect__namespace.unit));
+});
+const write = (stream, onError, encoding) => _ => Effect__namespace.async(resume => {
+  const cb = err => {
+    if (err) {
+      resume(Effect__namespace.fail(onError(err)));
+    } else {
+      resume(Effect__namespace.unit);
+    }
+  };
+  if (encoding) {
+    stream.write(_, encoding, cb);
+  } else {
+    stream.write(_, cb);
+  }
+});
+
+exports.fromWritable = fromWritable;

package/dist/stream-1456ece0.cjs.dev.js

@@ -0,0 +1,120 @@
+'use strict';
+
+var Effect = require('effect/Effect');
+var Function = require('effect/Function');
+var Option = require('effect/Option');
+var Stream = require('effect/Stream');
+
+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 Effect__namespace = /*#__PURE__*/_interopNamespace(Effect);
+var Option__namespace = /*#__PURE__*/_interopNamespace(Option);
+var Stream__namespace = /*#__PURE__*/_interopNamespace(Stream);
+
+/** @internal */
+const fromReadable = (evaluate, onError, {
+  chunkSize
+} = {}) => Function.pipe(Effect__namespace.acquireRelease(Effect__namespace.sync(evaluate), stream => Effect__namespace.sync(() => {
+  stream.removeAllListeners();
+  if (!stream.closed) {
+    stream.destroy();
+  }
+})), Effect__namespace.map(stream => Stream__namespace.async(emit => {
+  stream.once("error", err => {
+    emit.fail(onError(err));
+  });
+
+  // The 'close' event is emitted after a process has ended and the stdio
+  // streams of a child process have been closed. This is distinct from
+  // the 'exit' event, since multiple processes might share the same
+  // stdio streams. The 'close' event will always emit after 'exit' was
+  // already emitted, or 'error' if the child failed to spawn.
+  stream.once("close", () => {
+    emit.end();
+  });
+  stream.on("readable", () => {
+    emit.single(stream);
+  });
+  if (stream.readable) {
+    emit.single(stream);
+  }
+}, 1)), Stream__namespace.unwrapScoped, Stream__namespace.flatMap(_ => Stream__namespace.repeatEffectOption(readChunk(_, chunkSize))));
+const readChunk = (stream, size) => Function.pipe(Effect__namespace.sync(() => size ? stream.read(Number(size)) : stream.read()), Effect__namespace.flatMap(_ => _ ? Effect__namespace.succeed(_) : Effect__namespace.fail(Option__namespace.none())));
+
+/** @internal */
+const toString = options => {
+  const maxBytesNumber = options.maxBytes ? Number(options.maxBytes) : undefined;
+  return Effect__namespace.acquireUseRelease(Effect__namespace.sync(() => {
+    const stream = options.readable();
+    stream.setEncoding(options.encoding ?? "utf8");
+    return stream;
+  }), stream => Effect__namespace.async(resume => {
+    let string = "";
+    let bytes = 0;
+    stream.once("error", err => {
+      resume(Effect__namespace.fail(options.onFailure(err)));
+    });
+    stream.once("end", () => {
+      resume(Effect__namespace.succeed(string));
+    });
+    stream.on("data", chunk => {
+      string += chunk;
+      bytes += Buffer.byteLength(chunk);
+      if (maxBytesNumber && bytes > maxBytesNumber) {
+        resume(Effect__namespace.fail(options.onFailure(new Error("maxBytes exceeded"))));
+      }
+    });
+  }), stream => Effect__namespace.sync(() => {
+    stream.removeAllListeners();
+    if (!stream.closed) {
+      stream.destroy();
+    }
+  }));
+};
+
+/** @internal */
+const toUint8Array = options => {
+  const maxBytesNumber = options.maxBytes ? Number(options.maxBytes) : undefined;
+  return Effect__namespace.acquireUseRelease(Effect__namespace.sync(options.readable), stream => Effect__namespace.async(resume => {
+    let buffer = Buffer.alloc(0);
+    let bytes = 0;
+    stream.once("error", err => {
+      resume(Effect__namespace.fail(options.onFailure(err)));
+    });
+    stream.once("end", () => {
+      resume(Effect__namespace.succeed(buffer));
+    });
+    stream.on("data", chunk => {
+      buffer = Buffer.concat([buffer, chunk]);
+      bytes += chunk.length;
+      if (maxBytesNumber && bytes > maxBytesNumber) {
+        resume(Effect__namespace.fail(options.onFailure(new Error("maxBytes exceeded"))));
+      }
+    });
+  }), stream => Effect__namespace.sync(() => {
+    stream.removeAllListeners();
+    if (!stream.closed) {
+      stream.destroy();
+    }
+  }));
+};
+
+exports.fromReadable = fromReadable;
+exports.toString = toString;
+exports.toUint8Array = toUint8Array;

package/dist/stream-ef8b6a66.cjs.prod.js

@@ -0,0 +1,120 @@
+'use strict';
+
+var Effect = require('effect/Effect');
+var Function = require('effect/Function');
+var Option = require('effect/Option');
+var Stream = require('effect/Stream');
+
+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 Effect__namespace = /*#__PURE__*/_interopNamespace(Effect);
+var Option__namespace = /*#__PURE__*/_interopNamespace(Option);
+var Stream__namespace = /*#__PURE__*/_interopNamespace(Stream);
+
+/** @internal */
+const fromReadable = (evaluate, onError, {
+  chunkSize
+} = {}) => Function.pipe(Effect__namespace.acquireRelease(Effect__namespace.sync(evaluate), stream => Effect__namespace.sync(() => {
+  stream.removeAllListeners();
+  if (!stream.closed) {
+    stream.destroy();
+  }
+})), Effect__namespace.map(stream => Stream__namespace.async(emit => {
+  stream.once("error", err => {
+    emit.fail(onError(err));
+  });
+
+  // The 'close' event is emitted after a process has ended and the stdio
+  // streams of a child process have been closed. This is distinct from
+  // the 'exit' event, since multiple processes might share the same
+  // stdio streams. The 'close' event will always emit after 'exit' was
+  // already emitted, or 'error' if the child failed to spawn.
+  stream.once("close", () => {
+    emit.end();
+  });
+  stream.on("readable", () => {
+    emit.single(stream);
+  });
+  if (stream.readable) {
+    emit.single(stream);
+  }
+}, 1)), Stream__namespace.unwrapScoped, Stream__namespace.flatMap(_ => Stream__namespace.repeatEffectOption(readChunk(_, chunkSize))));
+const readChunk = (stream, size) => Function.pipe(Effect__namespace.sync(() => size ? stream.read(Number(size)) : stream.read()), Effect__namespace.flatMap(_ => _ ? Effect__namespace.succeed(_) : Effect__namespace.fail(Option__namespace.none())));
+
+/** @internal */
+const toString = options => {
+  const maxBytesNumber = options.maxBytes ? Number(options.maxBytes) : undefined;
+  return Effect__namespace.acquireUseRelease(Effect__namespace.sync(() => {
+    const stream = options.readable();
+    stream.setEncoding(options.encoding ?? "utf8");
+    return stream;
+  }), stream => Effect__namespace.async(resume => {
+    let string = "";
+    let bytes = 0;
+    stream.once("error", err => {
+      resume(Effect__namespace.fail(options.onFailure(err)));
+    });
+    stream.once("end", () => {
+      resume(Effect__namespace.succeed(string));
+    });
+    stream.on("data", chunk => {
+      string += chunk;
+      bytes += Buffer.byteLength(chunk);
+      if (maxBytesNumber && bytes > maxBytesNumber) {
+        resume(Effect__namespace.fail(options.onFailure(new Error("maxBytes exceeded"))));
+      }
+    });
+  }), stream => Effect__namespace.sync(() => {
+    stream.removeAllListeners();
+    if (!stream.closed) {
+      stream.destroy();
+    }
+  }));
+};
+
+/** @internal */
+const toUint8Array = options => {
+  const maxBytesNumber = options.maxBytes ? Number(options.maxBytes) : undefined;
+  return Effect__namespace.acquireUseRelease(Effect__namespace.sync(options.readable), stream => Effect__namespace.async(resume => {
+    let buffer = Buffer.alloc(0);
+    let bytes = 0;
+    stream.once("error", err => {
+      resume(Effect__namespace.fail(options.onFailure(err)));
+    });
+    stream.once("end", () => {
+      resume(Effect__namespace.succeed(buffer));
+    });
+    stream.on("data", chunk => {
+      buffer = Buffer.concat([buffer, chunk]);
+      bytes += chunk.length;
+      if (maxBytesNumber && bytes > maxBytesNumber) {
+        resume(Effect__namespace.fail(options.onFailure(new Error("maxBytes exceeded"))));
+      }
+    });
+  }), stream => Effect__namespace.sync(() => {
+    stream.removeAllListeners();
+    if (!stream.closed) {
+      stream.destroy();
+    }
+  }));
+};
+
+exports.fromReadable = fromReadable;
+exports.toString = toString;
+exports.toUint8Array = toUint8Array;

package/{mjs/internal/commandExecutor.mjs → internal/commandExecutor.esm.js}

@@ -1,16 +1,17 @@
-import { handleErrnoException } from "@effect/platform-node/internal/error";
-import { fromWritable } from "@effect/platform-node/internal/sink";
-import { fromReadable } from "@effect/platform-node/internal/stream";
-import * as Command from "@effect/platform/Command";
-import * as CommandExecutor from "@effect/platform/CommandExecutor";
-import * as FileSystem from "@effect/platform/FileSystem";
-import * as Effect from "effect/Effect";
-import { constUndefined, pipe } from "effect/Function";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import * as Sink from "effect/Sink";
-import * as Stream from "effect/Stream";
-import * as ChildProcess from "node:child_process";
+import * as Command from '@effect/platform/Command';
+import * as CommandExecutor from '@effect/platform/CommandExecutor';
+import * as FileSystem from '@effect/platform/FileSystem';
+import * as Effect from 'effect/Effect';
+import { pipe, constUndefined } from 'effect/Function';
+import * as Layer from 'effect/Layer';
+import * as Option from 'effect/Option';
+import * as Sink from 'effect/Sink';
+import * as Stream from 'effect/Stream';
+import * as ChildProcess from 'node:child_process';
+import { handleErrnoException } from './error.esm.js';
+import { fromWritable } from './sink.esm.js';
+import { fromReadable } from './stream.esm.js';
+
 const inputToStdioOption = stdin => Option.match(stdin, {
   onNone: () => "inherit",
   onSome: () => "pipe"
@@ -46,11 +47,13 @@ const runCommand = fileSystem => command => {
           handle.on("exit", () => {
             exited = true;
           });
+
           // If starting the process throws an error, make sure to capture it
           handle.on("error", err => {
             handle.kill("SIGKILL");
             resume(Effect.fail(toPlatformError("spawn", err, command)));
           });
+
           // If the process is assigned a process identifier, then we know it
           // was spawned successfully
           if (handle.pid) {
@@ -138,6 +141,8 @@ const runCommand = fileSystem => command => {
       }
   }
 };
+
 /** @internal */
-export const layer = /*#__PURE__*/Layer.effect(CommandExecutor.CommandExecutor, /*#__PURE__*/pipe(FileSystem.FileSystem, /*#__PURE__*/Effect.map(fileSystem => CommandExecutor.makeExecutor(runCommand(fileSystem)))));
-//# sourceMappingURL=commandExecutor.mjs.map
+const layer = /*#__PURE__*/Layer.effect(CommandExecutor.CommandExecutor, /*#__PURE__*/pipe(FileSystem.FileSystem, /*#__PURE__*/Effect.map(fileSystem => CommandExecutor.makeExecutor(runCommand(fileSystem)))));
+
+export { layer };

package/{mjs/internal/error.mjs → internal/error.esm.js}

@@ -1,6 +1,7 @@
-import { SystemError } from "@effect/platform/Error";
+import { SystemError } from '@effect/platform/Error';
+
 /** @internal */
-export const handleErrnoException = (module, method) => (err, [path]) => {
+const handleErrnoException = (module, method) => (err, [path]) => {
   let reason = "Unknown";
   switch (err.code) {
     case "ENOENT":
@@ -34,4 +35,5 @@ export const handleErrnoException = (module, method) => (err, [path]) => {
     message: err.message
   });
 };
-//# sourceMappingURL=error.mjs.map
+
+export { handleErrnoException };