@effect/platform 0.18.4 → 0.18.6

package/dist/ClientResponse-4524e99e.esm.js

@@ -0,0 +1,53 @@
+import { T as TypeId$1, f as fromWeb$1, s as schemaJson$1, a as schemaNoBody$1 } from './clientResponse-8c2ec6a3.esm.js';
+import { schemaBodyJson, schemaBodyUrlParams, schemaHeaders } from '../Http/IncomingMessage/dist/effect-platform-Http-IncomingMessage.esm.js';
+
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+const TypeId = TypeId$1;
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const fromWeb = fromWeb$1;
+
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+const schemaJson = schemaJson$1;
+
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+const schemaNoBody = schemaNoBody$1;
+
+var ClientResponse = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  TypeId: TypeId,
+  fromWeb: fromWeb,
+  schemaJson: schemaJson,
+  schemaNoBody: schemaNoBody,
+  schemaBodyJson: schemaBodyJson,
+  schemaBodyUrlParams: schemaBodyUrlParams,
+  schemaHeaders: schemaHeaders
+});
+
+export { ClientResponse as C, TypeId as T, schemaNoBody as a, fromWeb as f, schemaJson as s };

package/dist/{ClientResponse-8f65511e.cjs.prod.js → ClientResponse-fe4e69c8.cjs.prod.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var clientResponse = require('./clientResponse-2c6a83f1.cjs.prod.js');
+var clientResponse = require('./clientResponse-f9c57e83.cjs.prod.js');
 var Http_IncomingMessage_dist_effectPlatformHttpIncomingMessage = require('../Http/IncomingMessage/dist/effect-platform-Http-IncomingMessage.cjs.prod.js');
 
 /**
@@ -35,11 +35,18 @@ const fromWeb = clientResponse.fromWeb;
  */
 const schemaJson = clientResponse.schemaJson;
 
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+const schemaNoBody = clientResponse.schemaNoBody;
+
 var ClientResponse = /*#__PURE__*/Object.freeze({
   __proto__: null,
   TypeId: TypeId,
   fromWeb: fromWeb,
   schemaJson: schemaJson,
+  schemaNoBody: schemaNoBody,
   schemaBodyJson: Http_IncomingMessage_dist_effectPlatformHttpIncomingMessage.schemaBodyJson,
   schemaBodyUrlParams: Http_IncomingMessage_dist_effectPlatformHttpIncomingMessage.schemaBodyUrlParams,
   schemaHeaders: Http_IncomingMessage_dist_effectPlatformHttpIncomingMessage.schemaHeaders
@@ -49,3 +56,4 @@ exports.ClientResponse = ClientResponse;
 exports.TypeId = TypeId;
 exports.fromWeb = fromWeb;
 exports.schemaJson = schemaJson;
+exports.schemaNoBody = schemaNoBody;

package/dist/Command-d8ab0c8d.esm.js

@@ -0,0 +1,403 @@
+import * as Chunk from 'effect/Chunk';
+import * as Effect from 'effect/Effect';
+import { dual } from 'effect/Function';
+import * as HashMap from 'effect/HashMap';
+import * as Option from 'effect/Option';
+import { pipeArguments } from 'effect/Pipeable';
+import * as Stream from 'effect/Stream';
+import { C as CommandExecutor } from './commandExecutor-d6457489.esm.js';
+
+/** @internal */
+const CommandTypeId$1 = /*#__PURE__*/Symbol.for("@effect/platform/Command");
+
+/** @internal */
+const isCommand$1 = u => typeof u === "object" && u != null && CommandTypeId$1 in u;
+
+/** @internal */
+const env$1 = /*#__PURE__*/dual(2, (self, environment) => {
+  switch (self._tag) {
+    case "StandardCommand":
+      {
+        return {
+          ...self,
+          env: HashMap.union(self.env, HashMap.fromIterable(Object.entries(environment)))
+        };
+      }
+    case "PipedCommand":
+      {
+        return pipeTo$1(env$1(self.left, environment), env$1(self.right, environment));
+      }
+  }
+});
+
+/** @internal */
+const exitCode$1 = self => Effect.flatMap(CommandExecutor, executor => executor.exitCode(self));
+
+/** @internal */
+const feed$1 = /*#__PURE__*/dual(2, (self, input) => stdin$1(self, Stream.fromChunk(Chunk.of(new TextEncoder().encode(input)))));
+
+/** @internal */
+const flatten$1 = self => Array.from(flattenLoop(self));
+
+/** @internal */
+const flattenLoop = self => {
+  switch (self._tag) {
+    case "StandardCommand":
+      {
+        return Chunk.of(self);
+      }
+    case "PipedCommand":
+      {
+        return Chunk.appendAll(flattenLoop(self.left), flattenLoop(self.right));
+      }
+  }
+};
+
+/** @internal */
+const lines$1 = (command, encoding = "utf-8") => Effect.flatMap(CommandExecutor, executor => executor.lines(command, encoding));
+
+/** @internal */
+const make$1 = (command, ...args) => ({
+  [CommandTypeId$1]: CommandTypeId$1,
+  _tag: "StandardCommand",
+  command,
+  args,
+  env: HashMap.empty(),
+  cwd: Option.none(),
+  // The initial process input here does not matter, we just want the child
+  // process to default to `"pipe"` for the stdin stream.
+  stdin: Option.some(Stream.empty),
+  stdout: "pipe",
+  stderr: "pipe",
+  gid: Option.none(),
+  uid: Option.none(),
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+});
+
+/** @internal */
+const pipeTo$1 = /*#__PURE__*/dual(2, (self, into) => ({
+  [CommandTypeId$1]: CommandTypeId$1,
+  _tag: "PipedCommand",
+  left: self,
+  right: into,
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+}));
+
+/** @internal */
+const stderr$1 = /*#__PURE__*/dual(2, (self, output) => {
+  switch (self._tag) {
+    case "StandardCommand":
+      {
+        return {
+          ...self,
+          stderr: output
+        };
+      }
+    // For piped commands it only makes sense to provide `stderr` for the
+    // right-most command as the rest will be piped in.
+    case "PipedCommand":
+      {
+        return {
+          ...self,
+          right: stderr$1(self.right, output)
+        };
+      }
+  }
+});
+
+/** @internal */
+const stdin$1 = /*#__PURE__*/dual(2, (self, input) => {
+  switch (self._tag) {
+    case "StandardCommand":
+      {
+        return {
+          ...self,
+          stdin: Option.some(input)
+        };
+      }
+    // For piped commands it only makes sense to provide `stdin` for the
+    // left-most command as the rest will be piped in.
+    case "PipedCommand":
+      {
+        return {
+          ...self,
+          left: stdin$1(self.left, input)
+        };
+      }
+  }
+});
+
+/** @internal */
+const stdout$1 = /*#__PURE__*/dual(2, (self, output) => {
+  switch (self._tag) {
+    case "StandardCommand":
+      {
+        return {
+          ...self,
+          stdout: output
+        };
+      }
+    // For piped commands it only makes sense to provide `stderr` for the
+    // right-most command as the rest will be piped in.
+    case "PipedCommand":
+      {
+        return {
+          ...self,
+          right: stdout$1(self.right, output)
+        };
+      }
+  }
+});
+
+/** @internal */
+const start$1 = command => Effect.flatMap(CommandExecutor, executor => executor.start(command));
+
+/** @internal */
+const stream$1 = command => Stream.flatMap(CommandExecutor, process => process.stream(command));
+
+/** @internal */
+const streamLines$1 = command => Stream.flatMap(CommandExecutor, process => process.streamLines(command));
+
+/** @internal */
+const string$1 = /*#__PURE__*/dual(args => isCommand$1(args[0]), (command, encoding) => Effect.flatMap(CommandExecutor, executor => executor.string(command, encoding)));
+
+/** @internal */
+const workingDirectory$1 = /*#__PURE__*/dual(2, (self, cwd) => {
+  switch (self._tag) {
+    case "StandardCommand":
+      {
+        return {
+          ...self,
+          cwd: Option.some(cwd)
+        };
+      }
+    case "PipedCommand":
+      {
+        return pipeTo$1(workingDirectory$1(self.left, cwd), workingDirectory$1(self.right, cwd));
+      }
+  }
+});
+
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ */
+const CommandTypeId = CommandTypeId$1;
+
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * Configures the pipe that is established between the parent and child
+ * processes' `stdin` stream.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * Configures the pipes that are established between the parent and child
+ * processes `stderr` and `stdout` streams.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * Returns `true` if the specified value is a `Command`, otherwise returns
+ * `false`.
+ *
+ * @since 1.0.0
+ * @category refinements
+ */
+const isCommand = isCommand$1;
+
+/**
+ * Specify the environment variables that will be used when running this command.
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+const env = env$1;
+
+/**
+ * Returns the exit code of the command after the process has completed
+ * execution.
+ *
+ * @since 1.0.0
+ * @category execution
+ */
+const exitCode = exitCode$1;
+
+/**
+ * Feed a string to standard input (default encoding of UTF-8).
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+const feed = feed$1;
+
+/**
+ * Flatten this command to a non-empty array of standard commands.
+ *
+ * * For a `StandardCommand`, this simply returns a `1` element array
+ * * For a `PipedCommand`, all commands in the pipe will be extracted out into
+ *   a array from left to right
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+const flatten = flatten$1;
+
+/**
+ * Runs the command returning the output as an array of lines with the specified
+ * encoding.
+ *
+ * @since 1.0.0
+ * @category execution
+ */
+const lines = lines$1;
+
+/**
+ * Create a command with the specified process name and an optional list of
+ * arguments.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+const make = make$1;
+
+/**
+ * Pipe one command to another command from left to right.
+ *
+ * Conceptually, the equivalent of piping one shell command to another:
+ *
+ * ```sh
+ * command1 | command2
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+const pipeTo = pipeTo$1;
+
+/**
+ * Start running the command and return a handle to the running process.
+ *
+ * @since 1.0.0
+ * @category execution
+ */
+const start = start$1;
+
+/**
+ * Start running the command and return the output as a `Stream`.
+ *
+ * @since 1.0.0
+ * @category execution
+ */
+const stream = stream$1;
+
+/**
+ * Runs the command returning the output as an stream of lines with the
+ * specified encoding.
+ *
+ * @since 1.0.0
+ * @category execution
+ */
+const streamLines = streamLines$1;
+
+/**
+ * Runs the command returning the entire output as a string with the
+ * specified encoding.
+ *
+ * If an encoding is not specified, the encoding will default to `utf-8`.
+ *
+ * @since 1.0.0
+ * @category execution
+ */
+const string = string$1;
+
+/**
+ * Specify the standard error stream for a command.
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+const stderr = stderr$1;
+
+/**
+ * Specify the standard input stream for a command.
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+const stdin = stdin$1;
+
+/**
+ * Specify the standard output stream for a command.
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+const stdout = stdout$1;
+
+/**
+ * Set the working directory that will be used when this command will be run.
+ *
+ * For piped commands, the working directory of each command will be set to the
+ * specified working directory.
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+const workingDirectory = workingDirectory$1;
+
+var Command = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  CommandTypeId: CommandTypeId,
+  isCommand: isCommand,
+  env: env,
+  exitCode: exitCode,
+  feed: feed,
+  flatten: flatten,
+  lines: lines,
+  make: make,
+  pipeTo: pipeTo,
+  start: start,
+  stream: stream,
+  streamLines: streamLines,
+  string: string,
+  stderr: stderr,
+  stdin: stdin,
+  stdout: stdout,
+  workingDirectory: workingDirectory
+});
+
+export { Command as C, CommandTypeId as a, exitCode as b, flatten as c, stream as d, env as e, feed as f, streamLines as g, string as h, isCommand as i, stderr as j, stdin as k, lines as l, make as m, stdout as n, pipeTo as p, start as s, workingDirectory as w };

package/dist/CommandExecutor-5807b66b.esm.js

@@ -0,0 +1,80 @@
+import { C as CommandExecutor$2, P as ProcessTypeId$1, E as ExitCode$1, a as ProcessId$1, m as makeExecutor$1 } from './commandExecutor-d6457489.esm.js';
+
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category tags
+ */
+const CommandExecutor = CommandExecutor$2;
+
+/**
+ * @since 1.0.0
+ * @category symbols
+ */
+const ProcessTypeId = ProcessTypeId$1;
+
+/**
+ * @since 1.0.0
+ * @category symbols
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const ExitCode = ExitCode$1;
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const ProcessId = ProcessId$1;
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const makeExecutor = makeExecutor$1;
+
+var CommandExecutor$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  CommandExecutor: CommandExecutor,
+  ProcessTypeId: ProcessTypeId,
+  ExitCode: ExitCode,
+  ProcessId: ProcessId,
+  makeExecutor: makeExecutor
+});
+
+export { CommandExecutor$1 as C, ExitCode as E, ProcessTypeId as P, CommandExecutor as a, ProcessId as b, makeExecutor as m };

package/dist/Effectify-e5a9d266.esm.js

@@ -0,0 +1,43 @@
+import * as Effect from 'effect/Effect';
+
+/** @internal */
+const effectify$1 = (fn, onError, onSyncError) => (...args) => Effect.async(resume => {
+  try {
+    fn(...args, (err, result) => {
+      if (err) {
+        resume(Effect.fail(onError ? onError(err, args) : err));
+      } else {
+        resume(Effect.succeed(result));
+      }
+    });
+  } catch (err) {
+    resume(onSyncError ? Effect.fail(onSyncError(err, args)) : Effect.die(err));
+  }
+});
+
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * Converts a callback-based function to a function that returns an `Effect`.
+ *
+ * @since 1.0.0
+ */
+
+/**
+ * @category util
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ */
+const effectify = effectify$1;
+
+var Effectify = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  effectify: effectify
+});
+
+export { Effectify as E, effectify as e };

package/dist/Error-3099667c.esm.js

@@ -0,0 +1,75 @@
+import * as Data from 'effect/Data';
+
+/** @internal */
+const PlatformErrorTypeId$1 = /*#__PURE__*/Symbol.for("@effect/platform/Error/PlatformErrorTypeId");
+const make = tag => props => Data.struct({
+  [PlatformErrorTypeId$1]: PlatformErrorTypeId$1,
+  _tag: tag,
+  ...props
+});
+
+/** @internal */
+const badArgument = /*#__PURE__*/make("BadArgument");
+
+/** @internal */
+const systemError = /*#__PURE__*/make("SystemError");
+
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ * @category type id
+ */
+const PlatformErrorTypeId = PlatformErrorTypeId$1;
+
+/**
+ * @since 1.0.0
+ * @category type id
+ */
+
+/**
+ * @since 1.0.0
+ * @category error
+ */
+
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ * @category error
+ */
+
+/**
+ * @since 1.0.0
+ * @category error
+ */
+const BadArgument = badArgument;
+
+/**
+ * @since 1.0.0
+ * @category model
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category error
+ */
+const SystemError = systemError;
+
+var Error = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  PlatformErrorTypeId: PlatformErrorTypeId,
+  BadArgument: BadArgument,
+  SystemError: SystemError
+});
+
+export { BadArgument as B, Error as E, PlatformErrorTypeId as P, SystemError as S };