the-moby-effect/dist/esm/internal/demux/raw.js

Moby/Docker API client built using effect-ts

import * as Socket from "@effect/platform/Socket";
import * as Channel from "effect/Channel";
import * as Effect from "effect/Effect";
import * as Function from "effect/Function";
import * as Pipeable from "effect/Pipeable";
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 * as internalCompressed from "./compressed.js";
/** @internal */
export const RawContentType = "application/vnd.docker.raw-stream";
/** @internal */
export const RawSocketTypeId = /*#__PURE__*/Symbol.for("the-moby-effect/demux/RawSocket");
/** @internal */
export const RawChannelTypeId = /*#__PURE__*/Symbol.for("the-moby-effect/demux/RawChannel");
/** @internal */
export const makeRawSocket = underlying => ({
  underlying,
  "content-type": RawContentType,
  [RawSocketTypeId]: RawSocketTypeId,
  pipe() {
    return Pipeable.pipeArguments(this, arguments);
  }
});
/** @internal */
export const makeRawChannel = underlying => ({
  underlying,
  "content-type": RawContentType,
  [RawChannelTypeId]: RawChannelTypeId,
  pipe() {
    return Pipeable.pipeArguments(this, arguments);
  }
});
/** @internal */
export const isRawSocket = u => Predicate.hasProperty(u, RawSocketTypeId);
/** @internal */
export const isRawChannel = u => Predicate.hasProperty(u, RawChannelTypeId);
/** @internal */
export const responseIsRawResponse = response => response.headers["content-type"] === RawContentType;
/** @internal */
export const asRawChannel = input => isRawSocket(input) ? makeRawChannel(Socket.toChannel(input.underlying)) : input;
/** @internal */
export const rawToStream = input => Channel.toStream(asRawChannel(input).underlying);
/** @internal */
export const rawToSink = input => Channel.toSink(asRawChannel(input).underlying);
/** @internal */
export const rawFromStreamWith = () => input => makeRawChannel(Stream.toChannel(input));
/** @internal */
export const rawFromStream = input => rawFromStreamWith()(input);
/** @internal */
export const rawFromSink = input => makeRawChannel(Sink.toChannel(input));
/** @internal */
export const interleaveRaw = (stdout, stderr) => {
  return Stream.interleave(rawToStream(stdout), rawToStream(stderr));
};
/** @internal */
export const mergeRawToTaggedStream = (stdout, stderr, options) => Stream.mergeWithTag({
  stdout: rawToStream(asRawChannel(stdout)),
  stderr: rawToStream(asRawChannel(stderr))
}, {
  concurrency: "unbounded",
  bufferSize: options?.bufferSize
});
/** @internal */
export const demuxRawToSingleSink = /*#__PURE__*/Function.dual(arguments_ => isRawSocket(arguments_[0]) || isRawChannel(arguments_[0]), (socket, source, sink, options) => Function.pipe(source, Stream.pipeThroughChannelOrFail(asRawChannel(socket).underlying), Stream.decodeText(options?.encoding), Stream.run(sink)));
/** @internal */
export const demuxStdioRawTupled = /*#__PURE__*/Effect.fnUntraced(function* (sockets, options) {
  const {
    stderr,
    stdin,
    stdout
  } = sockets;
  const stdinSocketObject = Predicate.isNotUndefined(stdin) ? {
    stdin: stdin?.[1]
  } : {};
  const stdoutSocketObject = Predicate.isNotUndefined(stdout) ? {
    stdout: stdout?.[0]
  } : {};
  const stderrSocketObject = Predicate.isNotUndefined(stderr) ? {
    stderr: stderr?.[0]
  } : {};
  const stdinIoObject = Predicate.isNotUndefined(stdin) ? {
    stdin: stdin?.[0]
  } : {
    stdin: Stream.empty
  };
  const stdoutIoObject = Predicate.isNotUndefined(stdout) ? {
    stdout: stdout?.[1]
  } : {
    stdout: Sink.succeed(void 0)
  };
  const stderrIoObject = Predicate.isNotUndefined(stderr) ? {
    stderr: stderr?.[1]
  } : {
    stderr: Sink.succeed(void 0)
  };
  return yield* demuxStdioRawToSeparateSinks({
    ...stdinSocketObject,
    ...stdoutSocketObject,
    ...stderrSocketObject
  }, {
    ...stdinIoObject,
    ...stdoutIoObject,
    ...stderrIoObject
  }, options);
});
/** @internal */
export const demuxStdioRawToSingleSink = /*#__PURE__*/Function.dual(arguments_ => "stdin" in arguments_[0] || "stdout" in arguments_[0] || "stderr" in arguments_[0], /*#__PURE__*/Effect.fnUntraced(function* (sockets, source, sink, options) {
  const {
    stderr,
    stdin,
    stdout
  } = sockets;
  const stdoutStream = Predicate.isUndefined(stdout) ? Stream.empty : rawToStream(stdout);
  const stderrStream = Predicate.isUndefined(stderr) ? Stream.empty : rawToStream(stderr);
  const runInput = Predicate.isNotUndefined(stdin) ? demuxRawToSingleSink(stdin, source, Sink.drain, options) : Stream.run(source, Sink.drain);
  const runOutput = Stream.interleave(stdoutStream, stderrStream).pipe(Stream.decodeText(options?.encoding)).pipe(Stream.run(sink));
  return yield* Effect.map(Effect.all({
    ranStdin: runInput,
    ranOutput: runOutput
  }, {
    concurrency: 2
  }), ({
    ranOutput
  }) => ranOutput);
}));
/** @internal */
export const demuxStdioRawToSeparateSinks = /*#__PURE__*/Function.dual(arguments_ => !("stdin" in arguments_[0] && Predicate.hasProperty(arguments_[0]["stdin"], Stream.StreamTypeId)), /*#__PURE__*/Effect.fnUntraced(function* (sockets, io, options) {
  const {
    stderr,
    stdin,
    stdout
  } = sockets;
  const runStdin = Predicate.isNotUndefined(stdin) ? demuxRawToSingleSink(stdin, io.stdin, Sink.drain, options) : Stream.run(io.stdin, Sink.succeed(void 0));
  const runStdout = Predicate.isNotUndefined(stdout) ? demuxRawToSingleSink(stdout, Stream.never, io.stdout, options) : Stream.run(Stream.empty, io.stdout);
  const runStderr = Predicate.isNotUndefined(stderr) ? demuxRawToSingleSink(stderr, Stream.never, io.stderr, options) : Stream.run(Stream.empty, io.stderr);
  return yield* Effect.map(Effect.all({
    ranStdin: runStdin,
    ranStdout: runStdout,
    ranStderr: runStderr
  }, {
    concurrency: 3
  }), ({
    ranStderr,
    ranStdout
  }) => internalCompressed.compressDemuxOutput(Tuple.make(ranStdout, ranStderr)));
}));
//# sourceMappingURL=raw.js.map