the-moby-effect 1.45.0-alpha.2 → 1.45.0-alpha.21

package/dist/esm/demux/Demux.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Demux.js","names":["Socket","Function","Predicate","Stream","Tuple","demuxMultiplexedSocket","isMultiplexedStreamSocket","demuxRawSocket","demuxRawSockets","isRawStreamSocket","demuxToSingleSink","dual","arguments_","TypeId","undefined","socketOptions","source","sink","options","concat","never","absurd","demuxUnknownToSingleSink","demuxToSeparateSinks","sink1","sink2","stdinTuple","isNotUndefined","stdin","make","stdoutTuple","stdout","stderrTuple","stderr","demuxAnyToSeparateSinks","demuxUnknownToSeparateSinks"],"sources":["../../../src/demux/Demux.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/esm/demux/Hijack.js

@@ -0,0 +1,89 @@
+/**
+ * Utilities for hijacking a connection and transforming it into a raw stream.
+ * Only works on "server-side" platforms.
+ *
+ * @since 1.0.0
+ */
+import * as Socket from "@effect/platform/Socket";
+import * as Effect from "effect/Effect";
+import { makeMultiplexedStreamSocket, responseIsMultiplexedStreamSocketResponse } from "./Multiplexed.js";
+import { makeRawStreamSocket, responseIsRawStreamSocketResponse } from "./Raw.js";
+/**
+ * Hijacks an http response into a socket.
+ *
+ * FIXME: this function relies on a hack to expose the underlying tcp socket
+ * from the http client response. This will only work in NodeJs, not tested in
+ * Bun/Deno yet, and will never work in the browser.
+ *
+ * @since 1.0.0
+ * @category Transformations
+ */
+export const hijackResponseUnsafe = response => Effect.flatMap(Effect.promise(() => import("@effect/platform-node/NodeSocket")), nodeSocketLazy => {
+  const socket = response.source.socket;
+  return nodeSocketLazy.fromDuplex(Effect.sync(() => socket));
+});
+/**
+ * Transforms an http response into a multiplexed stream socket. If the response
+ * is not a multiplexed stream socket, then an error will be returned.
+ *
+ * FIXME: this function relies on a hack to expose the underlying tcp socket
+ * from the http client response. This will only work in NodeJs, not tested in
+ * Bun/Deno yet, and will never work in the browser.
+ *
+ * @since 1.0.0
+ * @category Predicates
+ */
+export const responseToMultiplexedStreamSocketOrFailUnsafe = response => {
+  if (!responseIsMultiplexedStreamSocketResponse(response)) {
+    return Effect.fail(new Socket.SocketGenericError({
+      reason: "Read",
+      cause: `Response with content type "${response.headers["content-type"]}" is not a multiplexed streaming socket`
+    }));
+  }
+  return Effect.map(hijackResponseUnsafe(response), makeMultiplexedStreamSocket);
+};
+/**
+ * Transforms an http response into a raw stream socket. If the response is not
+ * a raw stream socket, then an error will be returned.
+ *
+ * FIXME: this function relies on a hack to expose the underlying tcp socket
+ * from the http client response. This will only work in NodeJs, not tested in
+ * Bun/Deno yet, and will never work in the browser.
+ *
+ * @since 1.0.0
+ * @category Predicates
+ */
+export const responseToRawStreamSocketOrFailUnsafe = response => {
+  if (!responseIsRawStreamSocketResponse(response)) {
+    return Effect.fail(new Socket.SocketGenericError({
+      reason: "Read",
+      cause: `Response with content type "${response.headers["content-type"]}" is not a raw streaming socket`
+    }));
+  }
+  return Effect.map(hijackResponseUnsafe(response), makeRawStreamSocket);
+};
+/**
+ * Transforms an http response into a multiplexed stream socket or a raw stream
+ * socket. If the response is neither a multiplexed stream socket nor a raw or
+ * can not be transformed, then an error will be returned.
+ *
+ * FIXME: this function relies on a hack to expose the underlying tcp socket
+ * from the http client response. This will only work in NodeJs, not tested in
+ * Bun/Deno yet, and will never work in the browser.
+ *
+ * @since 1.0.0
+ * @category Predicates
+ */
+export const responseToStreamingSocketOrFailUnsafe = response => {
+  if (responseIsMultiplexedStreamSocketResponse(response)) {
+    return responseToMultiplexedStreamSocketOrFailUnsafe(response);
+  }
+  if (responseIsRawStreamSocketResponse(response)) {
+    return responseToRawStreamSocketOrFailUnsafe(response);
+  }
+  return Effect.fail(new Socket.SocketGenericError({
+    reason: "Read",
+    cause: "Response is not a streaming socket"
+  }));
+};
+//# sourceMappingURL=Hijack.js.map

package/dist/esm/demux/Hijack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Hijack.js","names":["Socket","Effect","makeMultiplexedStreamSocket","responseIsMultiplexedStreamSocketResponse","makeRawStreamSocket","responseIsRawStreamSocketResponse","hijackResponseUnsafe","response","flatMap","promise","nodeSocketLazy","socket","source","fromDuplex","sync","responseToMultiplexedStreamSocketOrFailUnsafe","fail","SocketGenericError","reason","cause","headers","map","responseToRawStreamSocketOrFailUnsafe","responseToStreamingSocketOrFailUnsafe"],"sources":["../../../src/demux/Hijack.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;AAQA,OAAO,KAAKA,MAAM,MAAM,yBAAyB;AACjD,OAAO,KAAKC,MAAM,MAAM,eAAe;AAGvC,SACIC,2BAA2B,EAE3BC,yCAAyC,QACtC,kBAAkB;AACzB,SAASC,mBAAmB,EAAmBC,iCAAiC,QAAQ,UAAU;AAElG;;;;;;;;;;AAUA,OAAO,MAAMC,oBAAoB,GAC7BC,QAA+C,IAE/CN,MAAM,CAACO,OAAO,CACVP,MAAM,CAACQ,OAAO,CAAC,MAAM,MAAM,CAAC,kCAAkC,CAAC,CAAC,EAC/DC,cAAc,IAAI;EACf,MAAMC,MAAM,GAAIJ,QAAoD,CAACK,MAAM,CAACD,MAAM;EAClF,OAAOD,cAAc,CAACG,UAAU,CAACZ,MAAM,CAACa,IAAI,CAAC,MAAMH,MAAM,CAAC,CAAC;AAC/D,CAAC,CACJ;AAEL;;;;;;;;;;;AAWA,OAAO,MAAMI,6CAA6C,GACtDR,QAA+C,IACoB;EACnE,IAAI,CAACJ,yCAAyC,CAACI,QAAQ,CAAC,EAAE;IACtD,OAAON,MAAM,CAACe,IAAI,CACd,IAAIhB,MAAM,CAACiB,kBAAkB,CAAC;MAC1BC,MAAM,EAAE,MAAM;MACdC,KAAK,EAAE,+BAA+BZ,QAAQ,CAACa,OAAO,CAAC,cAAc,CAAC;KACzE,CAAC,CACL;EACL;EAEA,OAAOnB,MAAM,CAACoB,GAAG,CAACf,oBAAoB,CAACC,QAAQ,CAAC,EAAEL,2BAA2B,CAAC;AAClF,CAAC;AAED;;;;;;;;;;;AAWA,OAAO,MAAMoB,qCAAqC,GAC9Cf,QAA+C,IACY;EAC3D,IAAI,CAACF,iCAAiC,CAACE,QAAQ,CAAC,EAAE;IAC9C,OAAON,MAAM,CAACe,IAAI,CACd,IAAIhB,MAAM,CAACiB,kBAAkB,CAAC;MAC1BC,MAAM,EAAE,MAAM;MACdC,KAAK,EAAE,+BAA+BZ,QAAQ,CAACa,OAAO,CAAC,cAAc,CAAC;KACzE,CAAC,CACL;EACL;EAEA,OAAOnB,MAAM,CAACoB,GAAG,CAACf,oBAAoB,CAACC,QAAQ,CAAC,EAAEH,mBAAmB,CAAC;AAC1E,CAAC;AAED;;;;;;;;;;;;AAYA,OAAO,MAAMmB,qCAAqC,GAC9ChB,QAA+C,IACsC;EACrF,IAAIJ,yCAAyC,CAACI,QAAQ,CAAC,EAAE;IACrD,OAAOQ,6CAA6C,CAACR,QAAQ,CAAC;EAClE;EAEA,IAAIF,iCAAiC,CAACE,QAAQ,CAAC,EAAE;IAC7C,OAAOe,qCAAqC,CAACf,QAAQ,CAAC;EAC1D;EAEA,OAAON,MAAM,CAACe,IAAI,CAAC,IAAIhB,MAAM,CAACiB,kBAAkB,CAAC;IAAEC,MAAM,EAAE,MAAM;IAAEC,KAAK,EAAE;EAAoC,CAAE,CAAC,CAAC;AACtH,CAAC","ignoreList":[]}

package/dist/esm/demux/Multiplexed.js

@@ -0,0 +1,143 @@
+/**
+ * Demux utilities for multiplexed sockets. You can receive data (both stdout
+ * and stderr) distinctly and send data (stdin) all over the same socket.
+ *
+ * @since 1.0.0
+ */
+import * as Socket from "@effect/platform/Socket";
+import * as Chunk from "effect/Chunk";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Predicate from "effect/Predicate";
+import * as Schedule from "effect/Schedule";
+import * as Schema from "effect/Schema";
+import * as Sink from "effect/Sink";
+import * as Stream from "effect/Stream";
+import * as Tuple from "effect/Tuple";
+import { compressDemuxOutput } from "./Compressed.js";
+/**
+ * @since 1.0.0
+ * @category Types
+ * @internal
+ */
+export var MultiplexedStreamSocketHeaderType;
+(function (MultiplexedStreamSocketHeaderType) {
+  MultiplexedStreamSocketHeaderType[MultiplexedStreamSocketHeaderType["Stdin"] = 0] = "Stdin";
+  MultiplexedStreamSocketHeaderType[MultiplexedStreamSocketHeaderType["Stdout"] = 1] = "Stdout";
+  MultiplexedStreamSocketHeaderType[MultiplexedStreamSocketHeaderType["Stderr"] = 2] = "Stderr";
+})(MultiplexedStreamSocketHeaderType || (MultiplexedStreamSocketHeaderType = {}));
+/**
+ * @since 1.0.0
+ * @category Schemas
+ * @internal
+ */
+export const MultiplexedStreamSocketSchema = /*#__PURE__*/Schema.Tuple(/*#__PURE__*/Schema.Enums(MultiplexedStreamSocketHeaderType), Schema.Uint8Array);
+/**
+ * @since 1.0.0
+ * @category Types
+ * @internal
+ */
+export const MultiplexedStreamSocketContentType = "application/vnd.docker.multiplexed-stream";
+/**
+ * @since 1.0.0
+ * @category Type ids
+ * @internal
+ */
+export const MultiplexedStreamSocketTypeId = /*#__PURE__*/Symbol.for("the-moby-effect/demux/MultiplexedStreamSocket");
+/**
+ * @since 1.0.0
+ * @category Constructors
+ * @internal
+ */
+export const makeMultiplexedStreamSocket = socket => ({
+  ...socket,
+  "content-type": MultiplexedStreamSocketContentType,
+  [MultiplexedStreamSocketTypeId]: MultiplexedStreamSocketTypeId
+});
+/**
+ * @since 1.0.0
+ * @category Predicates
+ */
+export const isMultiplexedStreamSocket = u => Predicate.hasProperty(u, MultiplexedStreamSocketTypeId);
+/**
+ * @since 1.0.0
+ * @category Predicates
+ * @internal
+ */
+export const responseIsMultiplexedStreamSocketResponse = response => response.headers["content-type"] === MultiplexedStreamSocketContentType;
+/**
+ * Accumulates the header and its message bytes into a single value.
+ *
+ * @since 1.0.0
+ * @category Demux
+ * @internal
+ */
+export const demuxMultiplexedSocketFolderSink = /*#__PURE__*/Sink.fold({
+  headerBytesRead: 0,
+  messageBytesRead: 0,
+  headerBuffer: /*#__PURE__*/Chunk.empty(),
+  messageBuffer: /*#__PURE__*/Chunk.empty(),
+  messageSize: undefined,
+  messageType: undefined
+}, ({
+  messageBytesRead,
+  messageSize
+}) => messageSize === undefined || messageBytesRead < messageSize, (accumulator, input) => {
+  // If we have not read the entire header yet
+  if (accumulator.headerBytesRead < 8) {
+    return {
+      ...accumulator,
+      headerBytesRead: accumulator.headerBytesRead + 1,
+      headerBuffer: Chunk.append(accumulator.headerBuffer, input)
+    };
+  }
+  // Lazily evaluate the header and message size
+  const uint8Array = () => new Uint8Array(Chunk.toReadonlyArray(accumulator.headerBuffer));
+  const type = () => accumulator.messageType ?? new DataView(uint8Array().buffer).getUint8(0);
+  const size = () => accumulator.messageSize ?? new DataView(uint8Array().buffer).getUint32(4);
+  // We can parse the header when we've read all 8 bytes and haven't parsed it yet
+  const needToParseHeader = accumulator.headerBytesRead === 8 && Predicate.isUndefined(accumulator.messageType) && Predicate.isUndefined(accumulator.messageSize);
+  // Otherwise, if we have read the entire header but not parsed it yet
+  const parsedHeader = needToParseHeader ? {
+    messageType: type(),
+    messageSize: size()
+  } : {};
+  return {
+    ...accumulator,
+    ...parsedHeader,
+    messageBytesRead: accumulator.messageBytesRead + 1,
+    messageBuffer: Chunk.append(accumulator.messageBuffer, input)
+  };
+});
+/**
+ * Demux a multiplexed socket. When given a multiplexed socket, we must parse
+ * the chunks by headers and then forward each chunk based on its datatype to
+ * the correct sink.
+ *
+ * When partitioning the stream into stdout and stderr, the first sink may
+ * advance by up to bufferSize elements further than the slower one. The default
+ * bufferSize is 16.
+ *
+ * @since 1.0.0
+ * @category Demux
+ */
+export const demuxMultiplexedSocket = /*#__PURE__*/Function.dual(arguments_ => arguments_[0][Socket.TypeId] !== undefined, (socket, source, sink1, sink2OrOptions, options) => {
+  const willPartition = Predicate.hasProperty(sink2OrOptions, Sink.SinkTypeId);
+  const untilPartition = Function.pipe(source, Stream.pipeThroughChannelOrFail(Socket.toChannel(socket)), Stream.mapConcat(Function.identity), Stream.aggregateWithin(demuxMultiplexedSocketFolderSink, Schedule.fixed(Duration.infinity)), Stream.map(({
+    messageBuffer,
+    messageType
+  }) => Tuple.make(messageType, Chunk.toReadonlyArray(messageBuffer))), Stream.flatMap(Schema.decodeUnknown(MultiplexedStreamSocketSchema)));
+  if (!willPartition) {
+    return Function.pipe(untilPartition, Stream.map(Tuple.getSecond), Stream.decodeText(sink2OrOptions?.encoding), Stream.run(sink1));
+  }
+  return Function.pipe(untilPartition, Stream.partition(([messageType]) => messageType === MultiplexedStreamSocketHeaderType.Stderr, {
+    bufferSize: options?.bufferSize
+  }), Effect.map(Tuple.mapBoth({
+    onFirst: Function.flow(Stream.map(Tuple.getSecond), Stream.decodeText(options?.encoding), Stream.run(sink1)),
+    onSecond: Function.flow(Stream.map(Tuple.getSecond), Stream.decodeText(options?.encoding), Stream.run(sink2OrOptions))
+  })), Effect.map(Effect.allWith({
+    concurrency: 2
+  })), Effect.flatten, Effect.map(compressDemuxOutput), Effect.scoped);
+});
+//# sourceMappingURL=Multiplexed.js.map

package/dist/esm/demux/Multiplexed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Multiplexed.js","names":["Socket","Chunk","Duration","Effect","Function","Predicate","Schedule","Schema","Sink","Stream","Tuple","compressDemuxOutput","MultiplexedStreamSocketHeaderType","MultiplexedStreamSocketSchema","Enums","Uint8Array","MultiplexedStreamSocketContentType","MultiplexedStreamSocketTypeId","Symbol","for","makeMultiplexedStreamSocket","socket","isMultiplexedStreamSocket","u","hasProperty","responseIsMultiplexedStreamSocketResponse","response","headers","demuxMultiplexedSocketFolderSink","fold","headerBytesRead","messageBytesRead","headerBuffer","empty","messageBuffer","messageSize","undefined","messageType","accumulator","input","append","uint8Array","toReadonlyArray","type","DataView","buffer","getUint8","size","getUint32","needToParseHeader","isUndefined","parsedHeader","demuxMultiplexedSocket","dual","arguments_","TypeId","source","sink1","sink2OrOptions","options","willPartition","SinkTypeId","untilPartition","pipe","pipeThroughChannelOrFail","toChannel","mapConcat","identity","aggregateWithin","fixed","infinity","map","make","flatMap","decodeUnknown","getSecond","decodeText","encoding","run","partition","Stderr","bufferSize","mapBoth","onFirst","flow","onSecond","allWith","concurrency","flatten","scoped"],"sources":["../../../src/demux/Multiplexed.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/esm/demux/Raw.js

@@ -0,0 +1,135 @@
+/**
+ * Demux utilities for raw sockets. Unlike multiplexed sockets, raw sockets can
+ * not differentiate between stdout and stderr because the data is just raw
+ * bytes from the process's PTY. However, you can attach multiple raw sockets to
+ * the same container (one for stdout and one for stderr) and then use the demux
+ * utilities to separate the streams.
+ *
+ * @since 1.0.0
+ */
+import * as Socket from "@effect/platform/Socket";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Predicate from "effect/Predicate";
+import * as Sink from "effect/Sink";
+import * as Stream from "effect/Stream";
+import * as Tuple from "effect/Tuple";
+import { compressDemuxOutput } from "./Compressed.js";
+/**
+ * @since 1.0.0
+ * @category Types
+ * @internal
+ */
+export const RawStreamSocketContentType = "application/vnd.docker.raw-stream";
+/**
+ * @since 1.0.0
+ * @category Type ids
+ * @internal
+ */
+export const RawStreamSocketTypeId = /*#__PURE__*/Symbol.for("the-moby-effect/demux/RawStreamSocket");
+/**
+ * @since 1.0.0
+ * @category Constructors
+ * @internal
+ */
+export const makeRawStreamSocket = socket => ({
+  ...socket,
+  "content-type": RawStreamSocketContentType,
+  [RawStreamSocketTypeId]: RawStreamSocketTypeId
+});
+/**
+ * @since 1.0.0
+ * @category Predicates
+ */
+export const isRawStreamSocket = u => Predicate.hasProperty(u, RawStreamSocketTypeId);
+/**
+ * @since 1.0.0
+ * @category Predicates
+ * @internal
+ */
+export const responseIsRawStreamSocketResponse = response => response.headers["content-type"] === RawStreamSocketContentType;
+/**
+ * Demux a raw socket. When given a raw socket of the remote process's pty,
+ * there is no way to differentiate between stdout and stderr so they are
+ * combined on the same sink.
+ *
+ * To demux multiple raw sockets, you should use {@link demuxRawSockets}
+ *
+ * @since 1.0.0
+ * @category Demux
+ */
+export const demuxRawSocket = /*#__PURE__*/Function.dual(arguments_ => isRawStreamSocket(arguments_[0]), (socket, source, sink, options) => Function.pipe(source, Stream.pipeThroughChannelOrFail(Socket.toChannel(socket)), Stream.decodeText(options?.encoding), Stream.run(sink)));
+/**
+ * Demux multiple raw sockets, created from multiple container attach requests.
+ * If no options are provided for a given stream, it will be ignored. This is
+ * really just an Effect.all wrapper around {@link demuxRawSocket}.
+ *
+ * To demux a single raw socket, you should use {@link demuxRawSocket}
+ *
+ * @since 1.0.0
+ * @category Demux
+ */
+export const demuxRawSockets = /*#__PURE__*/Function.dual(arguments_ => !(arguments_[0][Stream.StreamTypeId] !== undefined || "stdin" in arguments_[0] && arguments_[0]["stdin"]?.[Stream.StreamTypeId] !== undefined), (sockets, sourceOrIoOrOptions, sinkOrOptions, options) => {
+  const willMerge = sourceOrIoOrOptions?.[Stream.StreamTypeId] !== undefined;
+  const isIoObject = Predicate.isNotUndefined(sourceOrIoOrOptions) && "stdin" in sourceOrIoOrOptions && sourceOrIoOrOptions["stdin"]?.[Stream.StreamTypeId] !== undefined;
+  // Single sink case
+  if (willMerge) {
+    const sinkForBoth = sinkOrOptions;
+    const sourceStream = sourceOrIoOrOptions;
+    const {
+      stderr,
+      stdin,
+      stdout
+    } = sockets;
+    const transformToStream = socket => Function.pipe(Stream.empty, Stream.pipeThroughChannelOrFail(Socket.toChannel(socket)), Stream.decodeText(options?.encoding));
+    const mergedStream = Stream.merge(Predicate.isNotUndefined(stdout) ? transformToStream(stdout) : Stream.empty, Predicate.isNotUndefined(stderr) ? transformToStream(stderr) : Stream.empty);
+    const runMerged = Stream.run(mergedStream, sinkForBoth);
+    const runStdin = Predicate.isNotUndefined(stdin) ? demuxRawSocket(stdin, Stream.concat(sourceStream, Stream.make(new Socket.CloseEvent())), Sink.drain, options) : Effect.void;
+    return Effect.map(Effect.all({
+      ranStdin: runStdin,
+      ranMerged: runMerged
+    }, {
+      concurrency: 2
+    }), ({
+      ranMerged
+    }) => ranMerged);
+  }
+  // Multiple sinks case, combined input
+  if (!isIoObject) {
+    const {
+      stderr,
+      stdin,
+      stdout
+    } = sockets;
+    return demuxRawSockets({
+      stdin: stdin?.[1],
+      stdout: stdout?.[0],
+      stderr: stderr?.[0]
+    }, {
+      stdin: stdin?.[0] ?? Stream.empty,
+      stdout: stdout?.[1] ?? Sink.drain,
+      stderr: stderr?.[1] ?? Sink.drain
+    }, options);
+  }
+  // Multiple sinks case, regular input
+  const {
+    stderr,
+    stdin,
+    stdout
+  } = sockets;
+  const io = sourceOrIoOrOptions;
+  const runStdin = Predicate.isNotUndefined(stdin) ? demuxRawSocket(stdin, Stream.concat(io.stdin, Stream.make(new Socket.CloseEvent())), Sink.drain, options) : Stream.run(io.stdin, Sink.drain);
+  const runStdout = Predicate.isNotUndefined(stdout) ? demuxRawSocket(stdout, Stream.never, io.stdout, options) : Stream.run(Stream.empty, io.stdout);
+  const runStderr = Predicate.isNotUndefined(stderr) ? demuxRawSocket(stderr, Stream.never, io.stderr, options) : Stream.run(Stream.empty, io.stderr);
+  return Effect.map(Effect.all({
+    ranStdin: runStdin,
+    ranStdout: runStdout,
+    ranStderr: runStderr
+  }, {
+    concurrency: 3
+  }), ({
+    ranStderr,
+    ranStdout
+  }) => compressDemuxOutput(Tuple.make(ranStdout, ranStderr)));
+});
+//# sourceMappingURL=Raw.js.map

package/dist/esm/demux/Raw.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Raw.js","names":["Socket","Effect","Function","Predicate","Sink","Stream","Tuple","compressDemuxOutput","RawStreamSocketContentType","RawStreamSocketTypeId","Symbol","for","makeRawStreamSocket","socket","isRawStreamSocket","u","hasProperty","responseIsRawStreamSocketResponse","response","headers","demuxRawSocket","dual","arguments_","source","sink","options","pipe","pipeThroughChannelOrFail","toChannel","decodeText","encoding","run","demuxRawSockets","StreamTypeId","undefined","sockets","sourceOrIoOrOptions","sinkOrOptions","willMerge","isIoObject","isNotUndefined","sinkForBoth","sourceStream","stderr","stdin","stdout","transformToStream","empty","mergedStream","merge","runMerged","runStdin","concat","make","CloseEvent","drain","void","map","all","ranStdin","ranMerged","concurrency","io","runStdout","never","runStderr","ranStdout","ranStderr"],"sources":["../../../src/demux/Raw.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/esm/demux/Stdio.js

@@ -0,0 +1,84 @@
+/**
+ * Demux utilities for stdin, stdout/console.log, and stderr/console.error
+ *
+ * @since 1.0.0
+ */
+import * as Console from "effect/Console";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Sink from "effect/Sink";
+import { demuxUnknownToSeparateSinks } from "./Demux.js";
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export class StdinError extends /*#__PURE__*/Data.TaggedError("StdinError") {}
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export class StdoutError extends /*#__PURE__*/Data.TaggedError("StdoutError") {}
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export class StderrError extends /*#__PURE__*/Data.TaggedError("StderrError") {}
+/**
+ * Demux either a raw stream socket or a multiplexed stream socket from stdin to
+ * stdout and stderr. If given a raw stream socket, then stdout and stderr will
+ * be combined on the same sink. If given a multiplexed stream socket, then
+ * stdout and stderr will be forwarded to different sinks. If given multiple raw
+ * stream sockets, then you can provide different individual sockets for stdin,
+ * stdout, and stderr.
+ *
+ * If you are looking for a way to demux to the console instead of stdin,
+ * stdout, and stderr then see {@link demuxSocketWithInputToConsole}. Since we
+ * are interacting with stdin, stdout, and stderr this function dynamically
+ * imports the `@effect/platform-node` package.
+ *
+ * @since 1.0.0
+ * @category DemuxStdio
+ */
+export const demuxSocketFromStdinToStdoutAndStderr = (sockets, options) => Effect.flatMap(Effect.all({
+  NodeSinkLazy: Effect.promise(() => import("@effect/platform-node/NodeSink")),
+  NodeStreamLazy: Effect.promise(() => import("@effect/platform-node/NodeStream"))
+}, {
+  concurrency: 2
+}), ({
+  NodeSinkLazy,
+  NodeStreamLazy
+}) => {
+  const stdin = NodeStreamLazy.fromReadable(() => process.stdin, error => new StdinError({
+    cause: error,
+    message: `stdin is not readable: ${error}`
+  }));
+  const stdout = NodeSinkLazy.fromWritable(() => process.stdout, error => new StdoutError({
+    cause: error,
+    message: `stdout is not writable: ${error}`
+  }), {
+    endOnDone: false
+  });
+  const stderr = NodeSinkLazy.fromWritable(() => process.stderr, error => new StderrError({
+    cause: error,
+    message: `stderr is not writable: ${error}`
+  }), {
+    endOnDone: false
+  });
+  return demuxUnknownToSeparateSinks(sockets, stdin, stdout, stderr, options);
+});
+/**
+ * Demux either a raw stream socket or a multiplexed stream socket to the
+ * console. If given a raw stream socket, then stdout and stderr will be
+ * combined on the same sink. If given a multiplexed stream socket, then stdout
+ * and stderr will be forwarded to different sinks. If given multiple raw stream
+ * sockets, then you can provide different individual sockets for stdin, stdout,
+ * and stderr.
+ *
+ * If you are looking for a way to demux to stdin, stdout, and stderr instead of
+ * the console then see {@link demuxSocketFromStdinToStdoutAndStderr}.
+ *
+ * @since 1.0.0
+ * @category DemuxStdio
+ */
+export const demuxSocketWithInputToConsole = (sockets, input, options) => demuxUnknownToSeparateSinks(sockets, input, Sink.forEach(Console.log), Sink.forEach(Console.error), options);
+//# sourceMappingURL=Stdio.js.map

package/dist/esm/demux/Stdio.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Stdio.js","names":["Console","Data","Effect","Sink","demuxUnknownToSeparateSinks","StdinError","TaggedError","StdoutError","StderrError","demuxSocketFromStdinToStdoutAndStderr","sockets","options","flatMap","all","NodeSinkLazy","promise","NodeStreamLazy","concurrency","stdin","fromReadable","process","error","cause","message","stdout","fromWritable","endOnDone","stderr","demuxSocketWithInputToConsole","input","forEach","log"],"sources":["../../../src/demux/Stdio.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;AAOA,OAAO,KAAKA,OAAO,MAAM,gBAAgB;AACzC,OAAO,KAAKC,IAAI,MAAM,aAAa;AACnC,OAAO,KAAKC,MAAM,MAAM,eAAe;AAGvC,OAAO,KAAKC,IAAI,MAAM,aAAa;AAGnC,SAAqBC,2BAA2B,QAAQ,YAAY;AAEpE;;;;AAIA,OAAM,MAAOC,UAAW,sBAAQJ,IAAI,CAACK,WAAW,CAAC,YAAY,CAAsC;AAEnG;;;;AAIA,OAAM,MAAOC,WAAY,sBAAQN,IAAI,CAACK,WAAW,CAAC,aAAa,CAAsC;AAErG;;;;AAIA,OAAM,MAAOE,WAAY,sBAAQP,IAAI,CAACK,WAAW,CAAC,aAAa,CAAsC;AAErG;;;;;;;;;;;;;;;;AAgBA,OAAO,MAAMG,qCAAqC,GAAGA,CACjDC,OAA+B,EAC/BC,OAAwF,KAExFT,MAAM,CAACU,OAAO,CACVV,MAAM,CAACW,GAAG,CACN;EACIC,YAAY,EAAEZ,MAAM,CAACa,OAAO,CAAC,MAAM,MAAM,CAAC,gCAAgC,CAAC,CAAC;EAC5EC,cAAc,EAAEd,MAAM,CAACa,OAAO,CAAC,MAAM,MAAM,CAAC,kCAAkC,CAAC;CAClF,EACD;EAAEE,WAAW,EAAE;AAAC,CAAE,CACrB,EACD,CAAC;EAAEH,YAAY;EAAEE;AAAc,CAAE,KAAI;EACjC,MAAME,KAAK,GAAiDF,cAAc,CAACG,YAAY,CACnF,MAAMC,OAAO,CAACF,KAAK,EAClBG,KAAc,IAAK,IAAIhB,UAAU,CAAC;IAAEiB,KAAK,EAAED,KAAK;IAAEE,OAAO,EAAE,0BAA0BF,KAAK;EAAE,CAAE,CAAC,CACnG;EACD,MAAMG,MAAM,GAAoEV,YAAY,CAACW,YAAY,CACrG,MAAML,OAAO,CAACI,MAAM,EACnBH,KAAc,IAAK,IAAId,WAAW,CAAC;IAAEe,KAAK,EAAED,KAAK;IAAEE,OAAO,EAAE,2BAA2BF,KAAK;EAAE,CAAE,CAAC,EAClG;IAAEK,SAAS,EAAE;EAAK,CAAE,CACvB;EACD,MAAMC,MAAM,GAAoEb,YAAY,CAACW,YAAY,CACrG,MAAML,OAAO,CAACO,MAAM,EACnBN,KAAc,IAAK,IAAIb,WAAW,CAAC;IAAEc,KAAK,EAAED,KAAK;IAAEE,OAAO,EAAE,2BAA2BF,KAAK;EAAE,CAAE,CAAC,EAClG;IAAEK,SAAS,EAAE;EAAK,CAAE,CACvB;EAED,OAAOtB,2BAA2B,CAACM,OAAO,EAAEQ,KAAK,EAAEM,MAAM,EAAEG,MAAM,EAAEhB,OAAO,CAAC;AAC/E,CAAC,CACJ;AAEL;;;;;;;;;;;;;;AAcA,OAAO,MAAMiB,6BAA6B,GAAGA,CACzClB,OAA+B,EAC/BmB,KAAiD,EACjDlB,OAAwF,KAExFP,2BAA2B,CACvBM,OAAO,EACPmB,KAAK,EACL1B,IAAI,CAAC2B,OAAO,CAA6B9B,OAAO,CAAC+B,GAAG,CAAC,EACrD5B,IAAI,CAAC2B,OAAO,CAA6B9B,OAAO,CAACqB,KAAK,CAAC,EACvDV,OAAO,CACV","ignoreList":[]}

package/dist/esm/endpoints/Common.js

@@ -0,0 +1,48 @@
+/**
+ * Common request helpers
+ *
+ * @since 1.0.0
+ */
+import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
+import * as Array from "effect/Array";
+import * as Function from "effect/Function";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Record from "effect/Record";
+import * as Tuple from "effect/Tuple";
+/**
+ * Takes a key and an optional value and returns a function that either adds the
+ * key and value to the query parameters of a request if the value was a Some or
+ * does nothing to the request if the value is a None.
+ *
+ * @since 1.0.0
+ * @category Request Helpers
+ * @internal
+ */
+export const maybeAddQueryParameter = (key, value) => Option.match({
+  onNone: Function.constant(Function.identity),
+  onSome: val => HttpClientRequest.setUrlParam(key, String(val))
+})(value);
+/**
+ * Takes a key and an optional value and returns a function that either adds the
+ * key and value to the headers of a request if the value was a Some or does
+ * nothing to the request if the values is a None.
+ *
+ * @since 1.0.0
+ * @category Request Helpers
+ * @internal
+ */
+export const maybeAddHeader = (key, value) => Option.match({
+  onNone: Function.constant(Function.identity),
+  onSome: val => HttpClientRequest.setHeader(key, val)
+})(value);
+/**
+ * For a given set of filters, returns a function that adds the filters to the
+ * http request as a query parameter.
+ *
+ * @since 1.0.0
+ * @category Request Helpers
+ * @internal
+ */
+export const maybeAddFilters = filters => maybeAddQueryParameter("filters", Function.pipe(filters, Option.fromNullable, Option.map(Record.map(val => Predicate.isNullable(val) ? Array.empty : Tuple.make(JSON.stringify(val)))), Option.map(JSON.stringify)));
+//# sourceMappingURL=Common.js.map

package/dist/esm/endpoints/Common.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Common.js","names":["HttpClientRequest","Array","Function","Option","Predicate","Record","Tuple","maybeAddQueryParameter","key","value","match","onNone","constant","identity","onSome","val","setUrlParam","String","maybeAddHeader","setHeader","maybeAddFilters","filters","pipe","fromNullable","map","isNullable","empty","make","JSON","stringify"],"sources":["../../../src/endpoints/Common.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;AAMA,OAAO,KAAKA,iBAAiB,MAAM,oCAAoC;AACvE,OAAO,KAAKC,KAAK,MAAM,cAAc;AACrC,OAAO,KAAKC,QAAQ,MAAM,iBAAiB;AAC3C,OAAO,KAAKC,MAAM,MAAM,eAAe;AACvC,OAAO,KAAKC,SAAS,MAAM,kBAAkB;AAC7C,OAAO,KAAKC,MAAM,MAAM,eAAe;AACvC,OAAO,KAAKC,KAAK,MAAM,cAAc;AAErC;;;;;;;;;AASA,OAAO,MAAMC,sBAAsB,GAAGA,CAClCC,GAAW,EACXC,KAA6B,KAE7BN,MAAM,CAACO,KAAK,CAAC;EACTC,MAAM,EAAET,QAAQ,CAACU,QAAQ,CAACV,QAAQ,CAACW,QAAQ,CAAC;EAC5CC,MAAM,EAAGC,GAAY,IAAKf,iBAAiB,CAACgB,WAAW,CAACR,GAAG,EAAES,MAAM,CAACF,GAAG,CAAC;CAC3E,CAAC,CAACN,KAAK,CAAC;AAEb;;;;;;;;;AASA,OAAO,MAAMS,cAAc,GAAGA,CAC1BV,GAAW,EACXC,KAA4B,KAE5BN,MAAM,CAACO,KAAK,CAAC;EACTC,MAAM,EAAET,QAAQ,CAACU,QAAQ,CAACV,QAAQ,CAACW,QAAQ,CAAC;EAC5CC,MAAM,EAAGC,GAAW,IAAKf,iBAAiB,CAACmB,SAAS,CAACX,GAAG,EAAEO,GAAG;CAChE,CAAC,CAACN,KAAK,CAAC;AAEb;;;;;;;;AAQA,OAAO,MAAMW,eAAe,GACxBC,OAA2G,IAE3Gd,sBAAsB,CAClB,SAAS,EACTL,QAAQ,CAACoB,IAAI,CACTD,OAAO,EACPlB,MAAM,CAACoB,YAAY,EACnBpB,MAAM,CAACqB,GAAG,CACNnB,MAAM,CAACmB,GAAG,CAAET,GAAG,IAAMX,SAAS,CAACqB,UAAU,CAACV,GAAG,CAAC,GAAGd,KAAK,CAACyB,KAAK,GAAGpB,KAAK,CAACqB,IAAI,CAACC,IAAI,CAACC,SAAS,CAACd,GAAG,CAAC,CAAE,CAAC,CACnG,EACDZ,MAAM,CAACqB,GAAG,CAACI,IAAI,CAACC,SAAS,CAAC,CAC7B,CACJ","ignoreList":[]}