brass-runtime 1.14.0 → 1.16.0

package/dist/chunk-IJT6RRQ5.cjs

@@ -0,0 +1,93 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunkDJQ7OMMBcjs = require('./chunk-DJQ7OMMB.cjs');
+
+// src/http/effectRunner.ts
+function registerHttpEffect(effect, env, cb) {
+  let done = false;
+  let currentCancel;
+  const finish = (exit) => {
+    if (done) return;
+    done = true;
+    currentCancel = void 0;
+    cb(exit);
+  };
+  const run = (current, cont) => {
+    if (done) return;
+    switch (current._tag) {
+      case "Succeed":
+        cont({ _tag: "Success", value: current.value });
+        return;
+      case "Fail":
+        cont({ _tag: "Failure", cause: _chunkDJQ7OMMBcjs.Cause.fail(current.error) });
+        return;
+      case "Sync":
+        try {
+          cont({ _tag: "Success", value: current.thunk(env) });
+        } catch (e) {
+          cont({ _tag: "Failure", cause: _chunkDJQ7OMMBcjs.Cause.die(e) });
+        }
+        return;
+      case "Async": {
+        const cancel = current.register(env, (exit) => {
+          currentCancel = void 0;
+          if (done) return;
+          cont(exit);
+        });
+        currentCancel = typeof cancel === "function" ? cancel : void 0;
+        return;
+      }
+      case "FlatMap":
+        run(current.first, (exit) => {
+          if (done) return;
+          if (exit._tag === "Failure") {
+            cont(exit);
+            return;
+          }
+          try {
+            run(current.andThen(exit.value), cont);
+          } catch (e) {
+            cont({ _tag: "Failure", cause: _chunkDJQ7OMMBcjs.Cause.die(e) });
+          }
+        });
+        return;
+      case "Fold":
+        run(current.first, (exit) => {
+          if (done) return;
+          try {
+            if (exit._tag === "Success") {
+              run(current.onSuccess(exit.value), cont);
+              return;
+            }
+            if (exit.cause._tag === "Fail") {
+              run(current.onFailure(exit.cause.error), cont);
+              return;
+            }
+            cont(exit);
+          } catch (e) {
+            cont({ _tag: "Failure", cause: _chunkDJQ7OMMBcjs.Cause.die(e) });
+          }
+        });
+        return;
+      case "Fork":
+        cont({ _tag: "Success", value: void 0 });
+        return;
+    }
+  };
+  run(effect, finish);
+  return () => {
+    if (done) return;
+    const cancel = currentCancel;
+    currentCancel = void 0;
+    done = true;
+    try {
+      _optionalChain([cancel, 'optionalCall', _ => _()]);
+    } finally {
+      cb({ _tag: "Failure", cause: _chunkDJQ7OMMBcjs.Cause.interrupt() });
+    }
+  };
+}
+
+
+
+exports.registerHttpEffect = registerHttpEffect;

package/dist/chunk-J3H54ZRV.mjs

@@ -0,0 +1,131 @@
+import {
+  asyncEffect
+} from "./chunk-NOYZIMUJ.mjs";
+
+// src/core/stream/structuredConcurrency.ts
+function race(left, right, parentScope) {
+  return asyncEffect((env, cb) => {
+    const scope = parentScope.subScope();
+    let done = false;
+    const onResult = (exit) => {
+      if (done) return;
+      done = true;
+      scope.close(exit);
+      cb(exit);
+    };
+    const fiberLeft = scope.fork(left);
+    const fiberRight = scope.fork(right);
+    fiberLeft.join(onResult);
+    fiberRight.join(onResult);
+  });
+}
+function zipPar(left, right, parentScope) {
+  return asyncEffect((env, cb) => {
+    const scope = parentScope.subScope();
+    let leftExit = null;
+    let rightExit = null;
+    let done = false;
+    const checkDone = () => {
+      if (!leftExit || !rightExit || done) return;
+      done = true;
+      if (leftExit._tag === "Success" && rightExit._tag === "Success") {
+        scope.close({ _tag: "Success", value: void 0 });
+        cb({
+          _tag: "Success",
+          value: [leftExit.value, rightExit.value]
+        });
+        return;
+      }
+      let cause;
+      if (leftExit._tag === "Failure") {
+        cause = leftExit.cause;
+      } else if (rightExit._tag === "Failure") {
+        cause = rightExit.cause;
+      } else {
+        throw new Error("zipPar: unreachable state (no Failure exit)");
+      }
+      const errExit = {
+        _tag: "Failure",
+        cause
+      };
+      scope.close(errExit);
+      cb(errExit);
+    };
+    const f1 = scope.fork(left);
+    const f2 = scope.fork(right);
+    f1.join((exit) => {
+      leftExit = exit;
+      checkDone();
+    });
+    f2.join((exit) => {
+      rightExit = exit;
+      checkDone();
+    });
+  });
+}
+function collectAllPar(effects, parentScope) {
+  return asyncEffect((env, cb) => {
+    const scope = parentScope.subScope();
+    const results = new Array(effects.length);
+    let completed = 0;
+    let done = false;
+    effects.forEach((eff, i) => {
+      const f = scope.fork(eff);
+      f.join((exit) => {
+        if (done) return;
+        if (exit._tag === "Failure") {
+          done = true;
+          const errExit = {
+            _tag: "Failure",
+            cause: exit.cause
+          };
+          scope.close(errExit);
+          cb(errExit);
+          return;
+        }
+        results[i] = exit.value;
+        completed++;
+        if (completed === effects.length) {
+          done = true;
+          const successExit = {
+            _tag: "Success",
+            value: results
+          };
+          scope.close({ _tag: "Success", value: void 0 });
+          cb(successExit);
+        }
+      });
+    });
+  });
+}
+function raceWith(left, right, parentScope, onLeft, onRight) {
+  return asyncEffect((env, cb) => {
+    const scope = parentScope.subScope();
+    let done = false;
+    const fiberLeft = scope.fork(left);
+    const fiberRight = scope.fork(right);
+    const finish = (next) => {
+      scope.fork(next).join((exitNext) => {
+        scope.close(exitNext);
+        cb(exitNext);
+      });
+    };
+    fiberLeft.join((exitL) => {
+      if (done) return;
+      done = true;
+      finish(onLeft(exitL, fiberRight, scope));
+    });
+    fiberRight.join((exitR) => {
+      if (done) return;
+      done = true;
+      finish(onRight(exitR, fiberLeft, scope));
+    });
+  });
+}
+
+export {
+  race,
+  zipPar,
+  collectAllPar,
+  raceWith
+};