brass-runtime 1.12.1 → 1.13.3

package/dist/chunk-QRPYH5J7.mjs

@@ -0,0 +1,407 @@
+import {
+  Cause,
+  Exit,
+  Scope,
+  async,
+  asyncFail,
+  asyncFlatMap,
+  asyncFold,
+  asyncMapError,
+  asyncSucceed,
+  asyncSync,
+  fail,
+  flatMap,
+  getCurrentFiber,
+  map,
+  mapError,
+  none,
+  orElseOptional,
+  raceWith,
+  some,
+  succeed,
+  sync,
+  unsafeGetCurrentRuntime,
+  unsafeRunFoldWithEnv
+} from "./chunk-T5XJDGTQ.mjs";
+
+// src/core/stream/stream.ts
+var widenOpt = (opt) => opt._tag === "None" ? none : some(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 asyncSucceed([a, next]);
+    }
+    if (exit.cause._tag === "Interrupt") {
+      return async((_env, cb) => {
+        cb(Exit.failCause(Cause.interrupt()));
+      });
+    }
+    const opt = exit.cause.error;
+    if (opt._tag === "None") {
+      return winnerSide === "L" ? uncons(rightStream) : uncons(leftStream);
+    }
+    return asyncFail(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 async((_env, cb) => {
+    const runtime = unsafeGetCurrentRuntime();
+    const scope = new Scope(runtime);
+    const handler = raceWith(
+      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 fail(none);
+    case "Emit":
+      return map(
+        mapError(self.value, (e) => some(e)),
+        (a) => [a, EMPTY_STREAM]
+      );
+    case "FromPull":
+      return self.pull;
+    case "Concat":
+      return orElseOptional(
+        map(
+          uncons(self.left),
+          ([a, tail]) => [a, concatStream(tail, self.right)]
+        ),
+        () => uncons(self.right)
+      );
+    case "Flatten":
+      return flatMap(
+        uncons(self.stream),
+        ([head, tail]) => orElseOptional(
+          map(
+            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 async((env, cb) => {
+        const runtime = unsafeGetCurrentRuntime();
+        const scope = new Scope(runtime);
+        const fiber = getCurrentFiber();
+        fiber?.addFinalizer((exit) => {
+          try {
+            scope.close(exit);
+          } catch {
+          }
+        });
+        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(
+          async((env2, cb2) => {
+            const pull = uncons(s);
+            unsafeRunFoldWithEnv(
+              pull,
+              env2,
+              (cause) => {
+                const ex = Exit.failCause(cause);
+                closeWith(ex);
+                cb2(ex);
+              },
+              ([a, tail]) => {
+                cb2(Exit.succeed([a, wrap(tail)]));
+              }
+            );
+          })
+        );
+        scope.fork(self.acquire).join((ex) => {
+          if (ex._tag === "Failure") {
+            closeWith(ex);
+            cb({ _tag: "Failure", cause: { _tag: "Fail", error: some(ex.cause.error) } });
+            return;
+          }
+          scope.addFinalizer((exit) => self.release(exit));
+          const inner = ex.value;
+          unsafeGetCurrentRuntime().fork(uncons(wrap(inner))).join(cb);
+        });
+      });
+    case "Managed":
+      return async((env, cb) => {
+        const runtime = unsafeGetCurrentRuntime();
+        const scope = new Scope(runtime);
+        getCurrentFiber()?.addFinalizer((exit) => {
+          try {
+            scope.close(exit);
+          } catch {
+          }
+        });
+        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: some(ex.cause.error) } });
+            return;
+          }
+          const { stream: inner, release } = ex.value;
+          scope.addFinalizer((exit) => release(exit));
+          const wrap = (s) => fromPull(
+            async((env2, cb2) => {
+              uncons(s)(env2, (ex2) => {
+                if (ex2._tag === "Failure") {
+                  closeWith(ex2);
+                  cb2(ex2);
+                  return;
+                }
+                const [a, tail] = ex2.value;
+                cb2(Exit.succeed([a, wrap(tail)]));
+              });
+            })
+          );
+          unsafeGetCurrentRuntime().fork(uncons(wrap(inner))).join(cb);
+        });
+      });
+  }
+}
+function assertNever(x, msg) {
+  throw new Error(msg ?? `Unexpected value: ${String(x)}`);
+}
+function mapStream(self, f) {
+  switch (self._tag) {
+    case "Empty":
+      return emptyStream();
+    case "Emit":
+      return emitStream(map(self.value, f));
+    case "FromPull":
+      return fromPull(
+        map(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(
+        map(self.acquire, (s) => mapStream(s, f)),
+        self.release
+      );
+    case "Managed":
+      return managedStream(
+        map(self.acquire, ({ stream, release }) => ({
+          stream: mapStream(stream, f),
+          release
+        }))
+      );
+    default:
+      return assertNever(self);
+  }
+}
+function rangeStream(start, end) {
+  const go = (i) => fromPull(
+    i > end ? asyncFail(none) : asyncSucceed([i, go(i + 1)])
+  );
+  return go(start);
+}
+function zip(left, right) {
+  const pull = asyncFold(
+    asyncMapError(uncons(left), (opt) => widenOpt(opt)),
+    // si left termina o falla, el zip termina/falla igual
+    (opt) => asyncFail(opt),
+    ([a, tailL]) => asyncFold(
+      asyncMapError(uncons(right), (opt) => widenOpt(opt)),
+      (opt) => asyncFail(opt),
+      ([b, tailR]) => asyncSucceed([
+        [a, b],
+        zip(tailL, tailR)
+      ])
+    )
+  );
+  return fromPull(pull);
+}
+function foreachStream(stream, f) {
+  const loop = (cur) => asyncFold(
+    // uncons: Option<E> -> Option<E|E2>
+    asyncMapError(uncons(cur), (opt) => widenOpt(opt)),
+    (opt) => {
+      if (opt._tag === "None") return asyncSucceed(void 0);
+      return asyncFail(opt);
+    },
+    ([a, tail]) => asyncFlatMap(
+      // f(a): E2 -> Option<E|E2>
+      asyncMapError(f(a), (e2) => some(e2)),
+      () => loop(tail)
+    )
+  );
+  return asyncFold(
+    loop(stream),
+    (opt) => {
+      if (opt._tag === "None") return asyncSucceed(void 0);
+      return asyncFail(opt.value);
+    },
+    () => asyncSucceed(void 0)
+  );
+}
+function fromArray(values) {
+  let s = emptyStream();
+  for (let i = values.length - 1; i >= 0; i--) {
+    const head = emitStream(succeed(values[i]));
+    s = concatStream(head, s);
+  }
+  return s;
+}
+function collectStream(stream) {
+  const loop = (cur, acc) => asyncFold(
+    uncons(cur),
+    (opt) => {
+      if (opt._tag === "None") return succeed(acc);
+      return fail(opt);
+    },
+    ([a, tail]) => loop(tail, [...acc, a])
+  );
+  return mapError(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 = async((_, cb) => {
+    reader.read().then(({ done, value }) => {
+      if (done) {
+        cb({ _tag: "Failure", cause: { _tag: "Fail", error: none } });
+        return;
+      }
+      cb({
+        _tag: "Success",
+        value: [value, fromPull(pull)]
+      });
+    }).catch((e) => {
+      cb({ _tag: "Failure", cause: { _tag: "Fail", error: some(normalizeError(e)) } });
+    });
+  });
+  return fromPull(pull);
+}
+function streamFromReadableStream(body, normalizeError) {
+  if (!body) return emptyStream();
+  let reader;
+  return unwrapScoped(
+    // acquire: produce un ZStream
+    sync(() => {
+      reader = body.getReader();
+      return readerStream(reader, normalizeError);
+    }),
+    // release: se corre en fin / error / interrupción
+    () => asyncSync(() => {
+      try {
+        reader?.cancel();
+      } catch {
+      }
+    })
+  );
+}
+
+export {
+  widenOpt,
+  fromPull,
+  unwrapScoped,
+  managedStream,
+  mergeStream,
+  emptyStream,
+  emitStream,
+  concatStream,
+  flattenStream,
+  merge,
+  uncons,
+  assertNever,
+  mapStream,
+  rangeStream,
+  zip,
+  foreachStream,
+  fromArray,
+  collectStream,
+  streamFromReadableStream
+};