brass-runtime 1.14.0 → 1.16.0

package/dist/chunk-7V4KY4RL.mjs

@@ -0,0 +1,104 @@
+import {
+  unsafeGetCurrentRuntime
+} from "./chunk-G6IQOE4P.mjs";
+import {
+  asyncEffect,
+  asyncFail,
+  asyncFlatMap,
+  asyncFold,
+  asyncSucceed
+} from "./chunk-NOYZIMUJ.mjs";
+
+// src/core/runtime/combinators.ts
+function sleep(ms) {
+  return asyncEffect((_env, cb) => {
+    const delay = Math.max(0, Math.floor(ms));
+    const id = setTimeout(() => cb({ _tag: "Success", value: void 0 }), delay);
+    return () => clearTimeout(id);
+  });
+}
+function timeout(effect, ms) {
+  return asyncEffect((env, cb) => {
+    let done = false;
+    let timerId;
+    let effectRunning = true;
+    timerId = setTimeout(() => {
+      if (done) return;
+      done = true;
+      effectRunning = false;
+      cb({
+        _tag: "Failure",
+        cause: { _tag: "Fail", error: { _tag: "TimeoutError", ms } }
+      });
+    }, Math.max(0, Math.floor(ms)));
+    const runtime = unsafeGetCurrentRuntime();
+    const fiber = runtime.fork(effect);
+    fiber.join((exit) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timerId);
+      cb(exit);
+    });
+    return () => {
+      if (done) return;
+      done = true;
+      clearTimeout(timerId);
+      fiber.interrupt();
+    };
+  });
+}
+function retry(effect, policy) {
+  const shouldRetry = policy.shouldRetry ?? (() => true);
+  const jitter = policy.jitter ?? "full";
+  const maxElapsedMs = policy.maxElapsedMs;
+  const computeDelay = (attempt) => {
+    const exp = policy.baseDelayMs * Math.pow(2, attempt);
+    const capped = Math.min(exp, policy.maxDelayMs);
+    if (jitter === "none") return capped;
+    return Math.floor(Math.random() * capped);
+  };
+  const loop = (attempt, startedAt) => asyncFold(
+    effect,
+    (error) => {
+      if (attempt >= policy.maxRetries) return asyncFail(error);
+      if (!shouldRetry(error, attempt)) return asyncFail(error);
+      if (maxElapsedMs !== void 0) {
+        const elapsed = performance.now() - startedAt;
+        if (elapsed >= maxElapsedMs) return asyncFail(error);
+      }
+      const delay = computeDelay(attempt);
+      return asyncFlatMap(sleep(delay), () => loop(attempt + 1, startedAt));
+    },
+    (value) => asyncSucceed(value)
+  );
+  return asyncFlatMap(
+    { _tag: "Sync", thunk: () => performance.now() },
+    (startedAt) => loop(0, startedAt)
+  );
+}
+function retryN(effect, n) {
+  return retry(effect, {
+    maxRetries: n,
+    baseDelayMs: 0,
+    maxDelayMs: 0,
+    jitter: "none"
+  });
+}
+function retryWithBackoff(effect, opts = {}) {
+  return retry(effect, {
+    maxRetries: opts.maxRetries ?? 3,
+    baseDelayMs: opts.baseDelayMs ?? 100,
+    maxDelayMs: opts.maxDelayMs ?? 1e4,
+    maxElapsedMs: opts.maxElapsedMs,
+    shouldRetry: opts.shouldRetry,
+    jitter: "full"
+  });
+}
+
+export {
+  sleep,
+  timeout,
+  retry,
+  retryN,
+  retryWithBackoff
+};