@smthrs/platform-node 0.0.0-stage → 1.0.0-rc.4

package/dist/vendor/chunk-2Y7WC4KU.js

@@ -0,0 +1,109 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.0-rc.115_effect@4.0.0-rc.115_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeMultipartParser.js
+var NodeMultipartParser_exports = {};
+__export(NodeMultipartParser_exports, {
+  FileStream: () => FileStream,
+  MultipartStream: () => MultipartStream,
+  make: () => make
+});
+import { make as makeParser } from "effect/unstable/http/MultipartParser";
+import { Duplex, Readable } from "node:stream";
+var MultipartStream = class extends Duplex {
+  _parser;
+  _canWrite = true;
+  _writeCallback;
+  constructor(config) {
+    super({
+      readableObjectMode: true
+    });
+    let currentError;
+    let currentFile;
+    this._parser = makeParser({
+      ...config,
+      onField: (info, value) => {
+        if (currentError !== void 0) return;
+        const field = {
+          _tag: "Field",
+          info,
+          value
+        };
+        this.push(field);
+        this.emit("field", field);
+      },
+      onFile: (info) => {
+        if (currentError !== void 0) return (_) => {
+        };
+        const file = new FileStream(info, this);
+        currentFile = file;
+        this.push(file);
+        this.emit("file", file);
+        return (chunk) => {
+          if (currentError !== void 0) return;
+          this._canWrite = file.push(chunk);
+          if (chunk === null && !this._canWrite) {
+            currentFile = void 0;
+            this._resume();
+          }
+        };
+      },
+      onError: (error) => {
+        this.emit("error", error);
+        currentFile?.emit("error", error);
+        currentError = error;
+      },
+      onDone: () => {
+        this.push(null);
+      }
+    });
+  }
+  _resume() {
+    this._canWrite = true;
+    if (this._writeCallback !== void 0) {
+      const callback = this._writeCallback;
+      this._writeCallback = void 0;
+      callback();
+    }
+  }
+  _read(_size) {
+  }
+  _write(chunk, encoding, callback) {
+    this._parser.write(chunk instanceof Uint8Array ? chunk : Buffer.from(chunk, encoding));
+    if (this._canWrite) {
+      callback();
+    } else {
+      this._writeCallback = callback;
+    }
+  }
+  _final(callback) {
+    this._parser.end();
+    callback();
+  }
+};
+var make = (config) => new MultipartStream(config);
+var FileStream = class extends Readable {
+  _tag = "File";
+  filename;
+  info;
+  _parent;
+  constructor(info, parent) {
+    super();
+    this.info = info;
+    this._parent = parent;
+    this.filename = info.filename;
+  }
+  _read(_size) {
+    if (this._parent._canWrite === false) {
+      this._parent._resume();
+    }
+  }
+};
+
+export {
+  MultipartStream,
+  make,
+  FileStream,
+  NodeMultipartParser_exports
+};

package/dist/vendor/chunk-3GR5VZ2M.js

@@ -0,0 +1,118 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-node-shared/dist/NodeHttpCompression.js
+var NodeHttpCompression_exports = {};
+__export(NodeHttpCompression_exports, {
+  algorithms: () => algorithms,
+  compressTransform: () => compressTransform,
+  compressTransformWeb: () => compressTransformWeb,
+  make: () => make
+});
+import * as Effect from "effect/Effect";
+import * as HttpBody from "effect/unstable/http/HttpBody";
+import * as Response from "effect/unstable/http/HttpServerResponse";
+import { Readable } from "node:stream";
+import * as Zlib from "node:zlib";
+var algorithms = /* @__PURE__ */ new Set(typeof Zlib.zstdCompress === "function" ? ["gzip", "deflate", "br", "zstd"] : ["gzip", "deflate", "br"]);
+var brotliParams = (level, sizeHint) => {
+  const params = {};
+  if (level !== void 0) {
+    params[Zlib.constants.BROTLI_PARAM_QUALITY] = level;
+  }
+  if (sizeHint !== void 0) {
+    params[Zlib.constants.BROTLI_PARAM_SIZE_HINT] = sizeHint;
+  }
+  return {
+    params
+  };
+};
+var zstdParams = (level) => level === void 0 || level === 3 ? void 0 : {
+  params: {
+    [Zlib.constants.ZSTD_c_compressionLevel]: level
+  }
+};
+var compress = (data, algorithm, options) => Effect.callback((resume) => {
+  const complete = (error, result) => resume(error === null ? Effect.succeed(result) : Effect.die(error));
+  switch (algorithm) {
+    case "gzip": {
+      Zlib.gzip(data, {
+        level: options?.level
+      }, complete);
+      break;
+    }
+    case "deflate": {
+      Zlib.deflate(data, {
+        level: options?.level
+      }, complete);
+      break;
+    }
+    case "br": {
+      Zlib.brotliCompress(data, brotliParams(options?.level, data.byteLength), complete);
+      break;
+    }
+    case "zstd": {
+      const params = zstdParams(options?.level);
+      if (params === void 0) {
+        Zlib.zstdCompress(data, complete);
+      } else {
+        Zlib.zstdCompress(data, params, complete);
+      }
+      break;
+    }
+  }
+});
+var make = (fallback) => ({
+  algorithms: fallback.algorithms,
+  compressResponse(response, algorithm, options) {
+    const body = response.body;
+    if (body._tag !== "Uint8Array") {
+      return fallback.compressResponse(response, algorithm, options);
+    }
+    return Effect.map(compress(body.body, algorithm, options), (result) => Response.setHeader(Response.setBody(response, HttpBody.uint8Array(result, response.headers["content-type"] ?? body.contentType)), "content-length", result.byteLength.toString()));
+  }
+});
+var compressTransform = (algorithm, options) => {
+  switch (algorithm) {
+    case "gzip": {
+      return Zlib.createGzip({
+        level: options?.level,
+        flush: Zlib.constants.Z_SYNC_FLUSH
+      });
+    }
+    case "deflate": {
+      return Zlib.createDeflate({
+        level: options?.level,
+        flush: Zlib.constants.Z_SYNC_FLUSH
+      });
+    }
+    case "br": {
+      return Zlib.createBrotliCompress({
+        ...brotliParams(options?.level),
+        flush: Zlib.constants.BROTLI_OPERATION_FLUSH
+      });
+    }
+    case "zstd": {
+      return Zlib.createZstdCompress({
+        ...zstdParams(options?.level),
+        flush: Zlib.constants.ZSTD_e_flush
+      });
+    }
+  }
+};
+var compressTransformWeb = (algorithm, options) => (stream) => {
+  const transform = compressTransform(algorithm, options);
+  const source = Readable.fromWeb(stream);
+  source.on("error", (cause) => transform.destroy(cause));
+  transform.on("close", () => source.destroy());
+  return Readable.toWeb(source.pipe(transform));
+};
+
+export {
+  algorithms,
+  make,
+  compressTransform,
+  compressTransformWeb,
+  NodeHttpCompression_exports
+};

package/dist/vendor/chunk-42QKY6T6.js

@@ -0,0 +1,40 @@
+// ../../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-node-shared/dist/internal/utils.js
+import * as PlatformError from "effect/PlatformError";
+var handleErrnoException = (module, method) => (err, [path]) => {
+  let reason = "Unknown";
+  switch (err.code) {
+    case "ENOENT":
+      reason = "NotFound";
+      break;
+    case "EACCES":
+      reason = "PermissionDenied";
+      break;
+    case "EEXIST":
+      reason = "AlreadyExists";
+      break;
+    case "EISDIR":
+      reason = "BadResource";
+      break;
+    case "ENOTDIR":
+      reason = "BadResource";
+      break;
+    case "EBUSY":
+      reason = "Busy";
+      break;
+    case "ELOOP":
+      reason = "BadResource";
+      break;
+  }
+  return PlatformError.systemError({
+    _tag: reason,
+    module,
+    method,
+    pathOrDescriptor: path,
+    syscall: err.syscall,
+    cause: err
+  });
+};
+
+export {
+  handleErrnoException
+};

package/dist/vendor/chunk-54RLBMTZ.js

@@ -0,0 +1,61 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-node-shared/dist/NodePath.js
+var NodePath_exports = {};
+__export(NodePath_exports, {
+  layer: () => layer,
+  layerPosix: () => layerPosix,
+  layerWin32: () => layerWin32
+});
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { Path, TypeId } from "effect/Path";
+import { BadArgument } from "effect/PlatformError";
+import * as NodePath from "node:path";
+import * as NodeUrl from "node:url";
+var fileUrlOps = (windows) => ({
+  fromFileUrl: (url) => Effect.try({
+    try: () => NodeUrl.fileURLToPath(url, {
+      windows
+    }),
+    catch: (cause) => new BadArgument({
+      module: "Path",
+      method: "fromFileUrl",
+      cause
+    })
+  }),
+  toFileUrl: (path) => Effect.try({
+    try: () => NodeUrl.pathToFileURL(path, {
+      windows
+    }),
+    catch: (cause) => new BadArgument({
+      module: "Path",
+      method: "toFileUrl",
+      cause
+    })
+  })
+});
+var layerPosix = /* @__PURE__ */ Layer.succeed(Path)({
+  [TypeId]: TypeId,
+  ...NodePath.posix,
+  .../* @__PURE__ */ fileUrlOps(false)
+});
+var layerWin32 = /* @__PURE__ */ Layer.succeed(Path)({
+  [TypeId]: TypeId,
+  ...NodePath.win32,
+  .../* @__PURE__ */ fileUrlOps(true)
+});
+var layer = /* @__PURE__ */ Layer.succeed(Path)({
+  [TypeId]: TypeId,
+  ...NodePath,
+  .../* @__PURE__ */ fileUrlOps(void 0)
+});
+
+export {
+  layerPosix,
+  layerWin32,
+  layer,
+  NodePath_exports
+};

package/dist/vendor/chunk-5ZMHBXIK.js

@@ -0,0 +1,55 @@
+import {
+  NetSocket,
+  NodeWS,
+  fromDuplex,
+  layerNet,
+  layerTls,
+  makeNet,
+  makeNetChannel,
+  makeTls,
+  makeTlsChannel
+} from "./chunk-JJ24ARBQ.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.0-rc.115_effect@4.0.0-rc.115_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeSocket.js
+var NodeSocket_exports = {};
+__export(NodeSocket_exports, {
+  NetSocket: () => NetSocket,
+  NodeWS: () => NodeWS,
+  fromDuplex: () => fromDuplex,
+  layerNet: () => layerNet,
+  layerTls: () => layerTls,
+  layerWebSocket: () => layerWebSocket,
+  layerWebSocketConstructor: () => layerWebSocketConstructor,
+  layerWebSocketConstructorWS: () => layerWebSocketConstructorWS,
+  makeNet: () => makeNet,
+  makeNetChannel: () => makeNetChannel,
+  makeTls: () => makeTls,
+  makeTlsChannel: () => makeTlsChannel
+});
+import { flow } from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Socket from "effect/unstable/socket/Socket";
+var makeWebSocketWS = (url, options) => new NodeWS.WebSocket(url, options);
+var layerWebSocketConstructor = /* @__PURE__ */ Layer.sync(Socket.WebSocketConstructor)(() => {
+  if ("WebSocket" in globalThis) {
+    return (url, options) => {
+      if (options === void 0 || typeof options === "string" || Array.isArray(options)) {
+        return new globalThis.WebSocket(url, options);
+      }
+      return makeWebSocketWS(url, options);
+    };
+  }
+  return makeWebSocketWS;
+});
+var layerWebSocketConstructorWS = /* @__PURE__ */ Layer.succeed(Socket.WebSocketConstructor)(makeWebSocketWS);
+var layerWebSocket = /* @__PURE__ */ flow(Socket.makeWebSocket, /* @__PURE__ */ Layer.effect(Socket.Socket), /* @__PURE__ */ Layer.provide(layerWebSocketConstructor));
+
+export {
+  layerWebSocketConstructor,
+  layerWebSocketConstructorWS,
+  layerWebSocket,
+  NodeSocket_exports
+};

package/dist/vendor/chunk-6ME2W7TF.js

@@ -0,0 +1,28 @@
+import {
+  IncomingMessage,
+  layer,
+  layerTls,
+  layerWebSocket,
+  make,
+  makeTls,
+  makeWebSocket
+} from "./chunk-DWSHTSVX.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.0-rc.115_effect@4.0.0-rc.115_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeSocketServer.js
+var NodeSocketServer_exports = {};
+__export(NodeSocketServer_exports, {
+  IncomingMessage: () => IncomingMessage,
+  layer: () => layer,
+  layerTls: () => layerTls,
+  layerWebSocket: () => layerWebSocket,
+  make: () => make,
+  makeTls: () => makeTls,
+  makeWebSocket: () => makeWebSocket
+});
+
+export {
+  NodeSocketServer_exports
+};

package/dist/vendor/chunk-AMQKOQNT.js

@@ -0,0 +1,34 @@
+import {
+  layer as layer5
+} from "./chunk-KUUXSID7.js";
+import {
+  layer as layer6
+} from "./chunk-XDKNKFBW.js";
+import {
+  layer as layer4
+} from "./chunk-TFIKFFSC.js";
+import {
+  layer
+} from "./chunk-QPLDT6A6.js";
+import {
+  layer as layer2
+} from "./chunk-VZBDV3TV.js";
+import {
+  layer as layer3
+} from "./chunk-M32LDTW7.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.0-rc.115_effect@4.0.0-rc.115_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeServices.js
+var NodeServices_exports = {};
+__export(NodeServices_exports, {
+  layer: () => layer7
+});
+import * as Layer from "effect/Layer";
+var layer7 = /* @__PURE__ */ Layer.provideMerge(layer, /* @__PURE__ */ Layer.mergeAll(layer3, layer2, layer4, layer5, layer6));
+
+export {
+  layer7 as layer,
+  NodeServices_exports
+};

package/dist/vendor/chunk-B3FZ67QU.js

@@ -0,0 +1,59 @@
+import {
+  fromReadable
+} from "./chunk-XH4U3JSV.js";
+import {
+  fromWritable
+} from "./chunk-OXNGN5H7.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-node-shared/dist/NodeStdio.js
+var NodeStdio_exports = {};
+__export(NodeStdio_exports, {
+  layer: () => layer
+});
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { systemError } from "effect/PlatformError";
+import * as Stdio from "effect/Stdio";
+var layer = /* @__PURE__ */ Layer.succeed(Stdio.Stdio, /* @__PURE__ */ Stdio.make({
+  args: /* @__PURE__ */ Effect.sync(() => process.argv.slice(2)),
+  stdinIsTerminal: /* @__PURE__ */ Effect.sync(() => process.stdin.isTTY === true),
+  stdoutIsTerminal: /* @__PURE__ */ Effect.sync(() => process.stdout.isTTY === true),
+  stdout: (options) => fromWritable({
+    evaluate: () => process.stdout,
+    onError: (cause) => systemError({
+      module: "Stdio",
+      method: "stdout",
+      _tag: "Unknown",
+      cause
+    }),
+    endOnDone: options?.endOnDone ?? false
+  }),
+  stderr: (options) => fromWritable({
+    evaluate: () => process.stderr,
+    onError: (cause) => systemError({
+      module: "Stdio",
+      method: "stderr",
+      _tag: "Unknown",
+      cause
+    }),
+    endOnDone: options?.endOnDone ?? false
+  }),
+  stdin: /* @__PURE__ */ fromReadable({
+    evaluate: () => process.stdin,
+    onError: (cause) => systemError({
+      module: "Stdio",
+      method: "stdin",
+      _tag: "Unknown",
+      cause
+    }),
+    closeOnDone: false
+  })
+}));
+
+export {
+  layer,
+  NodeStdio_exports
+};