brass-runtime 1.13.8 → 1.14.0

package/dist/chunk-ZTDK2DLG.cjs

@@ -1,407 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-var _chunk2P4PD6D7cjs = require('./chunk-2P4PD6D7.cjs');
-
-// src/core/stream/stream.ts
-var widenOpt = (opt) => opt._tag === "None" ? _chunk2P4PD6D7cjs.none : _chunk2P4PD6D7cjs.some.call(void 0, opt.value);
-var fromPull = (pull) => ({
-  _tag: "FromPull",
-  pull
-});
-var unwrapScoped = (acquire, release) => ({
-  _tag: "Scoped",
-  acquire,
-  release
-});
-var managedStream = (acquire) => ({
-  _tag: "Managed",
-  acquire
-});
-var mergeStream = (left, right, flip = true) => ({
-  _tag: "Merge",
-  left,
-  right,
-  flip
-});
-var EMPTY_STREAM = { _tag: "Empty" };
-var emptyStream = () => EMPTY_STREAM;
-var emitStream = (value) => ({
-  _tag: "Emit",
-  value
-});
-var concatStream = (left, right) => ({
-  _tag: "Concat",
-  left,
-  right
-});
-var flattenStream = (stream) => ({
-  _tag: "Flatten",
-  stream
-});
-function streamToRaceWithHandler(winnerSide, leftStream, rightStream, flip, id) {
-  return (exit, otherFiber, scope) => {
-    if (exit._tag === "Failure") {
-    }
-    if (exit._tag === "Success") {
-    }
-    if (exit._tag === "Success") {
-      const [a, tailWin] = exit.value;
-      otherFiber.interrupt();
-      const next = winnerSide === "L" ? fromPull(makeMergePull(tailWin, rightStream, !flip, id)) : fromPull(makeMergePull(leftStream, tailWin, !flip, id));
-      return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, [a, next]);
-    }
-    if (exit.cause._tag === "Interrupt") {
-      return _chunk2P4PD6D7cjs.async.call(void 0, (_env, cb) => {
-        cb(_chunk2P4PD6D7cjs.Exit.failCause(_chunk2P4PD6D7cjs.Cause.interrupt()));
-      });
-    }
-    const opt = exit.cause.error;
-    if (opt._tag === "None") {
-      return winnerSide === "L" ? uncons(rightStream) : uncons(leftStream);
-    }
-    return _chunk2P4PD6D7cjs.asyncFail.call(void 0, opt);
-  };
-}
-function makeMergePull(onLeft, onRight, flip, mergePullId) {
-  const id = ++mergePullId;
-  const onLeftHandler = streamToRaceWithHandler("L", onLeft, onRight, flip, id);
-  const onRightHandler = streamToRaceWithHandler("R", onLeft, onRight, flip, id);
-  return _chunk2P4PD6D7cjs.async.call(void 0, (_env, cb) => {
-    const runtime = _chunk2P4PD6D7cjs.unsafeGetCurrentRuntime.call(void 0, );
-    const scope = new (0, _chunk2P4PD6D7cjs.Scope)(runtime);
-    const handler = _chunk2P4PD6D7cjs.raceWith.call(void 0, 
-      uncons(onLeft),
-      uncons(onRight),
-      scope,
-      onLeftHandler,
-      onRightHandler
-    );
-    scope.fork(handler).join((ex) => {
-      scope.close(ex);
-      cb(ex);
-    });
-  });
-}
-function merge(left, right) {
-  return fromPull(makeMergePull(left, right, true, 0));
-}
-function uncons(self) {
-  switch (self._tag) {
-    case "Empty":
-      return _chunk2P4PD6D7cjs.fail.call(void 0, _chunk2P4PD6D7cjs.none);
-    case "Emit":
-      return _chunk2P4PD6D7cjs.map.call(void 0, 
-        _chunk2P4PD6D7cjs.mapError.call(void 0, self.value, (e) => _chunk2P4PD6D7cjs.some.call(void 0, e)),
-        (a) => [a, EMPTY_STREAM]
-      );
-    case "FromPull":
-      return self.pull;
-    case "Concat":
-      return _chunk2P4PD6D7cjs.orElseOptional.call(void 0, 
-        _chunk2P4PD6D7cjs.map.call(void 0, 
-          uncons(self.left),
-          ([a, tail]) => [a, concatStream(tail, self.right)]
-        ),
-        () => uncons(self.right)
-      );
-    case "Flatten":
-      return _chunk2P4PD6D7cjs.flatMap.call(void 0, 
-        uncons(self.stream),
-        ([head, tail]) => _chunk2P4PD6D7cjs.orElseOptional.call(void 0, 
-          _chunk2P4PD6D7cjs.map.call(void 0, 
-            uncons(head),
-            ([a, as]) => [
-              a,
-              concatStream(as, flattenStream(tail))
-            ]
-          ),
-          () => uncons(flattenStream(tail))
-        )
-      );
-    case "Merge":
-      return makeMergePull(self.left, self.right, self.flip, 0);
-    case "Scoped":
-      return _chunk2P4PD6D7cjs.async.call(void 0, (env, cb) => {
-        const runtime = _chunk2P4PD6D7cjs.unsafeGetCurrentRuntime.call(void 0, );
-        const scope = new (0, _chunk2P4PD6D7cjs.Scope)(runtime);
-        const fiber = _chunk2P4PD6D7cjs.getCurrentFiber.call(void 0, );
-        _optionalChain([fiber, 'optionalAccess', _2 => _2.addFinalizer, 'call', _3 => _3((exit) => {
-          try {
-            scope.close(exit);
-          } catch (e3) {
-          }
-        })]);
-        const closeWith = (exit) => {
-          if (exit._tag === "Failure") {
-            const err = exit.cause.error;
-            if (err && typeof err === "object" && err._tag === "None") {
-              scope.close({ _tag: "Success", value: void 0 });
-              return;
-            }
-          }
-          scope.close(exit);
-        };
-        const wrap = (s) => fromPull(
-          _chunk2P4PD6D7cjs.async.call(void 0, (env2, cb2) => {
-            const pull = uncons(s);
-            _chunk2P4PD6D7cjs.unsafeRunFoldWithEnv.call(void 0, 
-              pull,
-              env2,
-              (cause) => {
-                const ex = _chunk2P4PD6D7cjs.Exit.failCause(cause);
-                closeWith(ex);
-                cb2(ex);
-              },
-              ([a, tail]) => {
-                cb2(_chunk2P4PD6D7cjs.Exit.succeed([a, wrap(tail)]));
-              }
-            );
-          })
-        );
-        scope.fork(self.acquire).join((ex) => {
-          if (ex._tag === "Failure") {
-            closeWith(ex);
-            cb({ _tag: "Failure", cause: { _tag: "Fail", error: _chunk2P4PD6D7cjs.some.call(void 0, ex.cause.error) } });
-            return;
-          }
-          scope.addFinalizer((exit) => self.release(exit));
-          const inner = ex.value;
-          _chunk2P4PD6D7cjs.unsafeGetCurrentRuntime.call(void 0, ).fork(uncons(wrap(inner))).join(cb);
-        });
-      });
-    case "Managed":
-      return _chunk2P4PD6D7cjs.async.call(void 0, (env, cb) => {
-        const runtime = _chunk2P4PD6D7cjs.unsafeGetCurrentRuntime.call(void 0, );
-        const scope = new (0, _chunk2P4PD6D7cjs.Scope)(runtime);
-        _optionalChain([_chunk2P4PD6D7cjs.getCurrentFiber.call(void 0, ), 'optionalAccess', _4 => _4.addFinalizer, 'call', _5 => _5((exit) => {
-          try {
-            scope.close(exit);
-          } catch (e4) {
-          }
-        })]);
-        const closeWith = (exit) => {
-          if (exit._tag === "Failure") {
-            const err = exit.cause.error;
-            if (err && typeof err === "object" && err._tag === "None") {
-              scope.close({ _tag: "Success", value: void 0 });
-              return;
-            }
-          }
-          scope.close(exit);
-        };
-        scope.fork(self.acquire).join((ex) => {
-          if (ex._tag === "Failure") {
-            scope.close(ex);
-            cb({ _tag: "Failure", cause: { _tag: "Fail", error: _chunk2P4PD6D7cjs.some.call(void 0, ex.cause.error) } });
-            return;
-          }
-          const { stream: inner, release } = ex.value;
-          scope.addFinalizer((exit) => release(exit));
-          const wrap = (s) => fromPull(
-            _chunk2P4PD6D7cjs.async.call(void 0, (env2, cb2) => {
-              uncons(s)(env2, (ex2) => {
-                if (ex2._tag === "Failure") {
-                  closeWith(ex2);
-                  cb2(ex2);
-                  return;
-                }
-                const [a, tail] = ex2.value;
-                cb2(_chunk2P4PD6D7cjs.Exit.succeed([a, wrap(tail)]));
-              });
-            })
-          );
-          _chunk2P4PD6D7cjs.unsafeGetCurrentRuntime.call(void 0, ).fork(uncons(wrap(inner))).join(cb);
-        });
-      });
-  }
-}
-function assertNever(x, msg) {
-  throw new Error(_nullishCoalesce(msg, () => ( `Unexpected value: ${String(x)}`)));
-}
-function mapStream(self, f) {
-  switch (self._tag) {
-    case "Empty":
-      return emptyStream();
-    case "Emit":
-      return emitStream(_chunk2P4PD6D7cjs.map.call(void 0, self.value, f));
-    case "FromPull":
-      return fromPull(
-        _chunk2P4PD6D7cjs.map.call(void 0, self.pull, ([a, tail]) => [f(a), mapStream(tail, f)])
-      );
-    case "Concat":
-      return concatStream(mapStream(self.left, f), mapStream(self.right, f));
-    case "Flatten": {
-      const mappedOuter = mapStream(
-        self.stream,
-        (inner) => mapStream(inner, f)
-      );
-      return flattenStream(mappedOuter);
-    }
-    case "Merge":
-      return mergeStream(
-        mapStream(self.left, f),
-        mapStream(self.right, f),
-        self.flip
-      );
-    case "Scoped":
-      return unwrapScoped(
-        _chunk2P4PD6D7cjs.map.call(void 0, self.acquire, (s) => mapStream(s, f)),
-        self.release
-      );
-    case "Managed":
-      return managedStream(
-        _chunk2P4PD6D7cjs.map.call(void 0, self.acquire, ({ stream, release }) => ({
-          stream: mapStream(stream, f),
-          release
-        }))
-      );
-    default:
-      return assertNever(self);
-  }
-}
-function rangeStream(start, end) {
-  const go = (i) => fromPull(
-    i > end ? _chunk2P4PD6D7cjs.asyncFail.call(void 0, _chunk2P4PD6D7cjs.none) : _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, [i, go(i + 1)])
-  );
-  return go(start);
-}
-function zip(left, right) {
-  const pull = _chunk2P4PD6D7cjs.asyncFold.call(void 0, 
-    _chunk2P4PD6D7cjs.asyncMapError.call(void 0, uncons(left), (opt) => widenOpt(opt)),
-    // si left termina o falla, el zip termina/falla igual
-    (opt) => _chunk2P4PD6D7cjs.asyncFail.call(void 0, opt),
-    ([a, tailL]) => _chunk2P4PD6D7cjs.asyncFold.call(void 0, 
-      _chunk2P4PD6D7cjs.asyncMapError.call(void 0, uncons(right), (opt) => widenOpt(opt)),
-      (opt) => _chunk2P4PD6D7cjs.asyncFail.call(void 0, opt),
-      ([b, tailR]) => _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, [
-        [a, b],
-        zip(tailL, tailR)
-      ])
-    )
-  );
-  return fromPull(pull);
-}
-function foreachStream(stream, f) {
-  const loop = (cur) => _chunk2P4PD6D7cjs.asyncFold.call(void 0, 
-    // uncons: Option<E> -> Option<E|E2>
-    _chunk2P4PD6D7cjs.asyncMapError.call(void 0, uncons(cur), (opt) => widenOpt(opt)),
-    (opt) => {
-      if (opt._tag === "None") return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, void 0);
-      return _chunk2P4PD6D7cjs.asyncFail.call(void 0, opt);
-    },
-    ([a, tail]) => _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
-      // f(a): E2 -> Option<E|E2>
-      _chunk2P4PD6D7cjs.asyncMapError.call(void 0, f(a), (e2) => _chunk2P4PD6D7cjs.some.call(void 0, e2)),
-      () => loop(tail)
-    )
-  );
-  return _chunk2P4PD6D7cjs.asyncFold.call(void 0, 
-    loop(stream),
-    (opt) => {
-      if (opt._tag === "None") return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, void 0);
-      return _chunk2P4PD6D7cjs.asyncFail.call(void 0, opt.value);
-    },
-    () => _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, void 0)
-  );
-}
-function fromArray(values) {
-  let s = emptyStream();
-  for (let i = values.length - 1; i >= 0; i--) {
-    const head = emitStream(_chunk2P4PD6D7cjs.succeed.call(void 0, values[i]));
-    s = concatStream(head, s);
-  }
-  return s;
-}
-function collectStream(stream) {
-  const loop = (cur, acc) => _chunk2P4PD6D7cjs.asyncFold.call(void 0, 
-    uncons(cur),
-    (opt) => {
-      if (opt._tag === "None") return _chunk2P4PD6D7cjs.succeed.call(void 0, acc);
-      return _chunk2P4PD6D7cjs.fail.call(void 0, opt);
-    },
-    ([a, tail]) => loop(tail, [...acc, a])
-  );
-  return _chunk2P4PD6D7cjs.mapError.call(void 0, loop(stream, []), (opt) => {
-    if (opt._tag === "Some") return opt.value;
-    throw new Error("unreachable: stream end handled as success");
-  });
-}
-function readerStream(reader, normalizeError) {
-  const pull = _chunk2P4PD6D7cjs.async.call(void 0, (_, cb) => {
-    reader.read().then(({ done, value }) => {
-      if (done) {
-        cb({ _tag: "Failure", cause: { _tag: "Fail", error: _chunk2P4PD6D7cjs.none } });
-        return;
-      }
-      cb({
-        _tag: "Success",
-        value: [value, fromPull(pull)]
-      });
-    }).catch((e) => {
-      cb({ _tag: "Failure", cause: { _tag: "Fail", error: _chunk2P4PD6D7cjs.some.call(void 0, normalizeError(e)) } });
-    });
-  });
-  return fromPull(pull);
-}
-function streamFromReadableStream(body, normalizeError) {
-  if (!body) return emptyStream();
-  let reader;
-  return unwrapScoped(
-    // acquire: produce un ZStream
-    _chunk2P4PD6D7cjs.sync.call(void 0, () => {
-      reader = body.getReader();
-      return readerStream(reader, normalizeError);
-    }),
-    // release: se corre en fin / error / interrupción
-    () => _chunk2P4PD6D7cjs.asyncSync.call(void 0, () => {
-      try {
-        _optionalChain([reader, 'optionalAccess', _6 => _6.cancel, 'call', _7 => _7()]);
-      } catch (e5) {
-      }
-    })
-  );
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.widenOpt = widenOpt; exports.fromPull = fromPull; exports.unwrapScoped = unwrapScoped; exports.managedStream = managedStream; exports.mergeStream = mergeStream; exports.emptyStream = emptyStream; exports.emitStream = emitStream; exports.concatStream = concatStream; exports.flattenStream = flattenStream; exports.merge = merge; exports.uncons = uncons; exports.assertNever = assertNever; exports.mapStream = mapStream; exports.rangeStream = rangeStream; exports.zip = zip; exports.foreachStream = foreachStream; exports.fromArray = fromArray; exports.collectStream = collectStream; exports.streamFromReadableStream = streamFromReadableStream;

package/dist/stream-BvukHxCv.d.ts

@@ -1,66 +0,0 @@
-import { Z as ZIO, O as Option, E as Exit, A as Async } from './effect-ISvXPLgc.js';
-
-type Empty<R, E, A> = {
-    readonly _tag: "Empty";
-};
-type Emit<R, E, A> = {
-    readonly _tag: "Emit";
-    readonly value: ZIO<R, E, A>;
-};
-type Concat<R, E, A> = {
-    readonly _tag: "Concat";
-    readonly left: ZStream<R, E, A>;
-    readonly right: ZStream<R, E, A>;
-};
-type Flatten<R, E, A> = {
-    readonly _tag: "Flatten";
-    readonly stream: ZStream<R, E, ZStream<R, E, A>>;
-};
-type FromPull<R, E, A> = {
-    readonly _tag: "FromPull";
-    readonly pull: ZIO<R, Option<E>, [A, ZStream<R, E, A>]>;
-};
-type Merge<R, E, A> = {
-    readonly _tag: "Merge";
-    readonly left: ZStream<R, E, A>;
-    readonly right: ZStream<R, E, A>;
-    readonly flip: boolean;
-};
-type Scoped<R, E, A> = {
-    readonly _tag: "Scoped";
-    readonly acquire: ZIO<R, E, ZStream<R, E, A>>;
-    readonly release: (exit: Exit<any, any>) => Async<R, any, void>;
-};
-type Managed<R, E, A> = {
-    readonly _tag: "Managed";
-    readonly acquire: ZIO<R, E, {
-        stream: ZStream<R, E, A>;
-        release: (exit: Exit<any, any>) => Async<R, any, void>;
-    }>;
-};
-type ZStream<R, E, A> = Empty<R, E, A> | Emit<R, E, A> | Concat<R, E, A> | FromPull<R, E, A> | Flatten<R, E, A> | Merge<R, E, A> | Scoped<R, E, A> | Managed<R, E, A>;
-type Normalize<E> = (u: unknown) => E;
-declare const widenOpt: <E1, E2>(opt: Option<E1>) => Option<E1 | E2>;
-declare const fromPull: <R, E, A>(pull: ZIO<R, Option<E>, [A, ZStream<R, E, A>]>) => ZStream<R, E, A>;
-declare const unwrapScoped: <R, E, A>(acquire: ZIO<R, E, ZStream<R, E, A>>, release: (exit: Exit<any, any>) => Async<R, any, void>) => ZStream<R, E, A>;
-declare const managedStream: <R, E, A>(acquire: ZIO<R, E, {
-    stream: ZStream<R, E, A>;
-    release: (exit: Exit<any, any>) => Async<R, any, void>;
-}>) => ZStream<R, E, A>;
-declare const mergeStream: <R, E, A>(left: ZStream<R, E, A>, right: ZStream<R, E, A>, flip?: boolean) => ZStream<R, E, A>;
-declare const emptyStream: <R, E, A>() => ZStream<R, E, A>;
-declare const emitStream: <R, E, A>(value: ZIO<R, E, A>) => ZStream<R, E, A>;
-declare const concatStream: <R, E, A>(left: ZStream<R, E, A>, right: ZStream<R, E, A>) => ZStream<R, E, A>;
-declare const flattenStream: <R, E, A>(stream: ZStream<R, E, ZStream<R, E, A>>) => ZStream<R, E, A>;
-declare function merge<R, E, A>(left: ZStream<R, E, A>, right: ZStream<R, E, A>): ZStream<R, E, A>;
-declare function uncons<R, E, A>(self: ZStream<R, E, A>): ZIO<R, Option<E>, [A, ZStream<R, E, A>]>;
-declare function assertNever(x: never, msg?: string): never;
-declare function mapStream<R, E, A, B>(self: ZStream<R, E, A>, f: (a: A) => B): ZStream<R, E, B>;
-declare function rangeStream(start: number, end: number): ZStream<unknown, never, number>;
-declare function zip<R, E1, A, E2, B>(left: ZStream<R, E1, A>, right: ZStream<R, E2, B>): ZStream<R, E1 | E2, [A, B]>;
-declare function foreachStream<R, E, A, R2, E2>(stream: ZStream<R, E, A>, f: (a: A) => Async<R2, E2, void>): Async<R & R2, E | E2, void>;
-declare function fromArray<A>(values: readonly A[]): ZStream<unknown, never, A>;
-declare function collectStream<R, E, A>(stream: ZStream<R, E, A>): ZIO<R, E, A[]>;
-declare function streamFromReadableStream<E>(body: ReadableStream<Uint8Array> | null | undefined, normalizeError: Normalize<E>): ZStream<unknown, E, Uint8Array>;
-
-export { type Concat as C, type Emit as E, type Flatten as F, type Managed as M, type Normalize as N, type Scoped as S, type ZStream as Z, type Empty as a, type FromPull as b, type Merge as c, assertNever as d, collectStream as e, concatStream as f, emitStream as g, emptyStream as h, flattenStream as i, foreachStream as j, fromArray as k, fromPull as l, managedStream as m, mapStream as n, merge as o, mergeStream as p, unwrapScoped as q, rangeStream as r, streamFromReadableStream as s, uncons as u, widenOpt as w, zip as z };