Initial commit of eigent-main

package/@stackframe/stack-shared/dist/esm/utils/results.js

@@ -0,0 +1,141 @@
+// src/utils/results.tsx
+import { wait } from "./promises";
+import { deindent, nicify } from "./strings";
+var Result = {
+  fromThrowing,
+  fromThrowingAsync,
+  fromPromise: promiseToResult,
+  ok(data) {
+    return {
+      status: "ok",
+      data
+    };
+  },
+  error(error) {
+    return {
+      status: "error",
+      error
+    };
+  },
+  map: mapResult,
+  or: (result, fallback) => {
+    return result.status === "ok" ? result.data : fallback;
+  },
+  orThrow: (result) => {
+    if (result.status === "error") {
+      throw result.error;
+    }
+    return result.data;
+  },
+  orThrowAsync: async (result) => {
+    return Result.orThrow(await result);
+  },
+  retry
+};
+var AsyncResult = {
+  fromThrowing,
+  fromPromise: promiseToResult,
+  ok: Result.ok,
+  error: Result.error,
+  pending,
+  map: mapResult,
+  or: (result, fallback) => {
+    if (result.status === "pending") {
+      return fallback;
+    }
+    return Result.or(result, fallback);
+  },
+  orThrow: (result) => {
+    if (result.status === "pending") {
+      throw new Error("Result still pending");
+    }
+    return Result.orThrow(result);
+  },
+  retry
+};
+function pending(progress) {
+  return {
+    status: "pending",
+    progress
+  };
+}
+async function promiseToResult(promise) {
+  try {
+    const value = await promise;
+    return Result.ok(value);
+  } catch (error) {
+    return Result.error(error);
+  }
+}
+function fromThrowing(fn) {
+  try {
+    return Result.ok(fn());
+  } catch (error) {
+    return Result.error(error);
+  }
+}
+async function fromThrowingAsync(fn) {
+  try {
+    return Result.ok(await fn());
+  } catch (error) {
+    return Result.error(error);
+  }
+}
+function mapResult(result, fn) {
+  if (result.status === "error") return {
+    status: "error",
+    error: result.error
+  };
+  if (result.status === "pending") return {
+    status: "pending",
+    ..."progress" in result ? { progress: result.progress } : {}
+  };
+  return Result.ok(fn(result.data));
+}
+var RetryError = class extends AggregateError {
+  constructor(errors) {
+    const strings = errors.map((e) => nicify(e));
+    const isAllSame = strings.length > 1 && strings.every((s) => s === strings[0]);
+    super(
+      errors,
+      deindent`
+      Error after ${errors.length} attempts.
+      
+      ${isAllSame ? deindent`
+        Attempts 1-${errors.length}:
+          ${strings[0]}
+      ` : strings.map((s, i) => deindent`
+          Attempt ${i + 1}:
+            ${s}
+        `).join("\n\n")}
+      `,
+      { cause: errors[errors.length - 1] }
+    );
+    this.errors = errors;
+    this.name = "RetryError";
+  }
+  get attempts() {
+    return this.errors.length;
+  }
+};
+RetryError.prototype.name = "RetryError";
+async function retry(fn, totalAttempts, { exponentialDelayBase = 1e3 } = {}) {
+  const errors = [];
+  for (let i = 0; i < totalAttempts; i++) {
+    const res = await fn(i);
+    if (res.status === "ok") {
+      return Object.assign(Result.ok(res.data), { attempts: i + 1 });
+    } else {
+      errors.push(res.error);
+      if (i < totalAttempts - 1) {
+        await wait((Math.random() + 0.5) * exponentialDelayBase * 2 ** i);
+      }
+    }
+  }
+  return Object.assign(Result.error(new RetryError(errors)), { attempts: totalAttempts });
+}
+export {
+  AsyncResult,
+  Result
+};
+//# sourceMappingURL=results.js.map