brass-runtime 1.14.0 → 1.16.0

package/dist/chunk-DJQ7OMMB.cjs

@@ -0,0 +1,144 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/core/types/asyncEffect.ts
+var Async = {
+  succeed: (value) => ({ _tag: "Succeed", value }),
+  fail: (error) => ({ _tag: "Fail", error }),
+  sync: (thunk) => ({ _tag: "Sync", thunk }),
+  async: (register) => ({ _tag: "Async", register })
+};
+function asyncFold(fa, onFailure, onSuccess) {
+  return {
+    _tag: "Fold",
+    first: fa,
+    onFailure,
+    onSuccess
+  };
+}
+function asyncCatchAll(fa, handler) {
+  return asyncFold(fa, handler, asyncSucceed);
+}
+function asyncMapError(fa, f) {
+  return asyncFold(fa, (e) => asyncFail(f(e)), asyncSucceed);
+}
+var SUCCEED_UNDEFINED = { _tag: "Succeed", value: void 0 };
+var SUCCEED_TRUE = { _tag: "Succeed", value: true };
+var SUCCEED_FALSE = { _tag: "Succeed", value: false };
+var SUCCEED_NULL = { _tag: "Succeed", value: null };
+var unit = () => SUCCEED_UNDEFINED;
+var asyncSucceed = (value) => {
+  if (value === void 0) return SUCCEED_UNDEFINED;
+  if (value === true) return SUCCEED_TRUE;
+  if (value === false) return SUCCEED_FALSE;
+  if (value === null) return SUCCEED_NULL;
+  return { _tag: "Succeed", value };
+};
+var asyncFail = (error) => ({
+  _tag: "Fail",
+  error
+});
+var asyncSync = (thunk) => ({
+  _tag: "Sync",
+  thunk
+});
+var asyncTotal = (thunk) => asyncSync(() => thunk());
+var asyncEffect = (register) => ({
+  _tag: "Async",
+  register
+});
+function asyncMap(fa, f) {
+  return asyncFlatMap(fa, (a) => asyncSucceed(f(a)));
+}
+function asyncFlatMap(fa, f) {
+  return {
+    _tag: "FlatMap",
+    first: fa,
+    andThen: f
+  };
+}
+function acquireRelease(acquire, release, scope) {
+  return asyncFlatMap(acquire, (resource) => {
+    scope.addFinalizer((exit) => release(resource, exit));
+    return asyncSucceed(resource);
+  });
+}
+function asyncInterruptible(register) {
+  return asyncEffect(register);
+}
+var withAsyncPromise = (run) => (eff) => {
+  const anyEff = eff;
+  if (!anyEff.toPromise) {
+    anyEff.toPromise = (env) => run(eff, env);
+    anyEff.unsafeRunPromise = () => run(eff, {});
+  }
+  return anyEff;
+};
+var mapAsync = (fa, f) => asyncFlatMap(fa, (a) => asyncSucceed(f(a)));
+var mapTryAsync = (fa, f) => asyncFlatMap(fa, (a) => asyncSync(() => f(a)));
+
+// src/core/types/option.ts
+var none = { _tag: "None" };
+var some = (value) => ({ _tag: "Some", value });
+
+// src/core/types/effect.ts
+var Cause = {
+  fail: (error) => ({ _tag: "Fail", error }),
+  interrupt: () => ({ _tag: "Interrupt" }),
+  die: (defect) => ({ _tag: "Die", defect })
+};
+var Exit = {
+  succeed: (value) => ({
+    _tag: "Success",
+    value
+  }),
+  failCause: (cause) => ({
+    _tag: "Failure",
+    cause
+  })
+};
+var succeed = (value) => asyncSucceed(value);
+var fail = (error) => asyncFail(error);
+var sync = (thunk) => asyncSync((env) => thunk(env));
+var map = (fa, f) => asyncMap(fa, f);
+var flatMap = (fa, f) => asyncFlatMap(fa, f);
+var mapError = (fa, f) => asyncMapError(fa, f);
+var catchAll = (fa, handler) => asyncFold(fa, handler, asyncSucceed);
+function orElseOptional(fa, that) {
+  return asyncFold(
+    fa,
+    (opt) => opt._tag === "Some" ? asyncFail(opt) : that(),
+    asyncSucceed
+  );
+}
+var end = () => fail(none);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.Async = Async; exports.asyncFold = asyncFold; exports.asyncCatchAll = asyncCatchAll; exports.asyncMapError = asyncMapError; exports.unit = unit; exports.asyncSucceed = asyncSucceed; exports.asyncFail = asyncFail; exports.asyncSync = asyncSync; exports.asyncTotal = asyncTotal; exports.asyncEffect = asyncEffect; exports.asyncMap = asyncMap; exports.asyncFlatMap = asyncFlatMap; exports.acquireRelease = acquireRelease; exports.asyncInterruptible = asyncInterruptible; exports.withAsyncPromise = withAsyncPromise; exports.mapAsync = mapAsync; exports.mapTryAsync = mapTryAsync; exports.none = none; exports.some = some; exports.Cause = Cause; exports.Exit = Exit; exports.succeed = succeed; exports.fail = fail; exports.sync = sync; exports.map = map; exports.flatMap = flatMap; exports.mapError = mapError; exports.catchAll = catchAll; exports.orElseOptional = orElseOptional; exports.end = end;