Initial commit of eigent-main

package/@stackframe/stack-shared/dist/esm/hooks/use-async-callback.js

@@ -0,0 +1,38 @@
+// src/hooks/use-async-callback.tsx
+import React from "react";
+import { captureError } from "../utils/errors";
+function useAsyncCallback(callback, deps) {
+  const [error, setError] = React.useState(void 0);
+  const [loadingCount, setLoadingCount] = React.useState(0);
+  const cb = React.useCallback(
+    async (...args) => {
+      setLoadingCount((c) => c + 1);
+      try {
+        return await callback(...args);
+      } catch (e) {
+        setError(e);
+        throw e;
+      } finally {
+        setLoadingCount((c) => c - 1);
+      }
+    },
+    deps
+  );
+  return [cb, loadingCount > 0, error];
+}
+function useAsyncCallbackWithLoggedError(callback, deps) {
+  const [newCallback, loading] = useAsyncCallback(async (...args) => {
+    try {
+      return await callback(...args);
+    } catch (e) {
+      captureError("async-callback", e);
+      throw e;
+    }
+  }, deps);
+  return [newCallback, loading];
+}
+export {
+  useAsyncCallback,
+  useAsyncCallbackWithLoggedError
+};
+//# sourceMappingURL=use-async-callback.js.map

package/@stackframe/stack-shared/dist/esm/hooks/use-async-callback.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/hooks/use-async-callback.tsx"],"sourcesContent":["import React from \"react\";\nimport { captureError } from \"../utils/errors\";\n\nexport function useAsyncCallback<A extends any[], R>(\n  callback: (...args: A) => Promise<R>,\n  deps: React.DependencyList\n): [cb: (...args: A) => Promise<R>, loading: boolean, error: unknown | undefined] {\n  const [error, setError] = React.useState<unknown | undefined>(undefined);\n  const [loadingCount, setLoadingCount] = React.useState(0);\n\n  const cb = React.useCallback(\n    async (...args: A) => {\n      setLoadingCount((c) => c + 1);\n      try {\n        return await callback(...args);\n      } catch (e) {\n        setError(e);\n        throw e;\n      } finally {\n        setLoadingCount((c) => c - 1);\n      }\n    },\n    deps,\n  );\n\n  return [cb, loadingCount > 0, error];\n}\n\nexport function useAsyncCallbackWithLoggedError<A extends any[], R>(\n  callback: (...args: A) => Promise<R>,\n  deps: React.DependencyList\n): [cb: (...args: A) => Promise<R>, loading: boolean] {\n  const [newCallback, loading] = useAsyncCallback<A, R>(async (...args) => {\n    try {\n      return await callback(...args);\n    } catch (e) {\n      captureError(\"async-callback\", e);\n      throw e;\n    }\n  }, deps);\n\n  return [newCallback, loading];\n}\n"],"mappings":";AAAA,OAAO,WAAW;AAClB,SAAS,oBAAoB;AAEtB,SAAS,iBACd,UACA,MACgF;AAChF,QAAM,CAAC,OAAO,QAAQ,IAAI,MAAM,SAA8B,MAAS;AACvE,QAAM,CAAC,cAAc,eAAe,IAAI,MAAM,SAAS,CAAC;AAExD,QAAM,KAAK,MAAM;AAAA,IACf,UAAU,SAAY;AACpB,sBAAgB,CAAC,MAAM,IAAI,CAAC;AAC5B,UAAI;AACF,eAAO,MAAM,SAAS,GAAG,IAAI;AAAA,MAC/B,SAAS,GAAG;AACV,iBAAS,CAAC;AACV,cAAM;AAAA,MACR,UAAE;AACA,wBAAgB,CAAC,MAAM,IAAI,CAAC;AAAA,MAC9B;AAAA,IACF;AAAA,IACA;AAAA,EACF;AAEA,SAAO,CAAC,IAAI,eAAe,GAAG,KAAK;AACrC;AAEO,SAAS,gCACd,UACA,MACoD;AACpD,QAAM,CAAC,aAAa,OAAO,IAAI,iBAAuB,UAAU,SAAS;AACvE,QAAI;AACF,aAAO,MAAM,SAAS,GAAG,IAAI;AAAA,IAC/B,SAAS,GAAG;AACV,mBAAa,kBAAkB,CAAC;AAChC,YAAM;AAAA,IACR;AAAA,EACF,GAAG,IAAI;AAEP,SAAO,CAAC,aAAa,OAAO;AAC9B;","names":[]}

package/@stackframe/stack-shared/dist/esm/hooks/use-async-external-store.js

@@ -0,0 +1,23 @@
+// src/hooks/use-async-external-store.tsx
+import { useEffect, useState } from "react";
+import { AsyncResult } from "../utils/results";
+function useAsyncExternalStore(subscribe) {
+  const [isAvailable, setIsAvailable] = useState(false);
+  const [value, setValue] = useState();
+  useEffect(() => {
+    const unsubscribe = subscribe((value2) => {
+      setValue(() => value2);
+      setIsAvailable(() => true);
+    });
+    return unsubscribe;
+  }, [subscribe]);
+  if (isAvailable) {
+    return AsyncResult.ok(value);
+  } else {
+    return AsyncResult.pending();
+  }
+}
+export {
+  useAsyncExternalStore
+};
+//# sourceMappingURL=use-async-external-store.js.map

package/@stackframe/stack-shared/dist/esm/hooks/use-async-external-store.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/hooks/use-async-external-store.tsx"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport { AsyncResult } from \"../utils/results\";\n\nexport function useAsyncExternalStore<T>(\n  subscribe: (callback: (t: T) => void) => (() => void),\n): AsyncResult<T, never> & { status: \"ok\" | \"pending\" } {\n  // sure, the \"sync\" in useSyncExternalStore refers to \"synchronize a store\" and not \"sync/async\", but it's too good of a name to pass up on\n\n  const [isAvailable, setIsAvailable] = useState(false);\n  const [value, setValue] = useState<T>();\n  useEffect(() => {\n    const unsubscribe = subscribe((value: T) => {\n      setValue(() => value);\n      setIsAvailable(() => true);\n    });\n    return unsubscribe;\n  }, [subscribe]);\n\n  if (isAvailable) {\n    return AsyncResult.ok(value as T);\n  } else {\n    return AsyncResult.pending();\n  }\n}\n"],"mappings":";AAAA,SAAS,WAAW,gBAAgB;AACpC,SAAS,mBAAmB;AAErB,SAAS,sBACd,WACsD;AAGtD,QAAM,CAAC,aAAa,cAAc,IAAI,SAAS,KAAK;AACpD,QAAM,CAAC,OAAO,QAAQ,IAAI,SAAY;AACtC,YAAU,MAAM;AACd,UAAM,cAAc,UAAU,CAACA,WAAa;AAC1C,eAAS,MAAMA,MAAK;AACpB,qBAAe,MAAM,IAAI;AAAA,IAC3B,CAAC;AACD,WAAO;AAAA,EACT,GAAG,CAAC,SAAS,CAAC;AAEd,MAAI,aAAa;AACf,WAAO,YAAY,GAAG,KAAU;AAAA,EAClC,OAAO;AACL,WAAO,YAAY,QAAQ;AAAA,EAC7B;AACF;","names":["value"]}

package/@stackframe/stack-shared/dist/esm/hooks/use-hash.js

@@ -0,0 +1,17 @@
+// src/hooks/use-hash.tsx
+import { useSyncExternalStore } from "react";
+import { suspendIfSsr } from "../utils/react";
+var useHash = () => {
+  suspendIfSsr("useHash");
+  return useSyncExternalStore(
+    (onChange) => {
+      const interval = setInterval(() => onChange(), 10);
+      return () => clearInterval(interval);
+    },
+    () => window.location.hash.substring(1)
+  );
+};
+export {
+  useHash
+};
+//# sourceMappingURL=use-hash.js.map

package/@stackframe/stack-shared/dist/esm/hooks/use-hash.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/hooks/use-hash.tsx"],"sourcesContent":["import { useSyncExternalStore } from \"react\";\nimport { suspendIfSsr } from \"../utils/react\";\n\nexport const useHash = () => {\n  suspendIfSsr(\"useHash\");\n  return useSyncExternalStore(\n    (onChange) => {\n      const interval = setInterval(() => onChange(), 10);\n      return () => clearInterval(interval);\n    },\n    () => window.location.hash.substring(1)\n  );\n};\n\n"],"mappings":";AAAA,SAAS,4BAA4B;AACrC,SAAS,oBAAoB;AAEtB,IAAM,UAAU,MAAM;AAC3B,eAAa,SAAS;AACtB,SAAO;AAAA,IACL,CAAC,aAAa;AACZ,YAAM,WAAW,YAAY,MAAM,SAAS,GAAG,EAAE;AACjD,aAAO,MAAM,cAAc,QAAQ;AAAA,IACrC;AAAA,IACA,MAAM,OAAO,SAAS,KAAK,UAAU,CAAC;AAAA,EACxC;AACF;","names":[]}

package/@stackframe/stack-shared/dist/esm/hooks/use-strict-memo.js

@@ -0,0 +1,61 @@
+// src/hooks/use-strict-memo.tsx
+import { useId, useInsertionEffect } from "react";
+import { Result } from "../utils/results";
+var cached = /* @__PURE__ */ new Map();
+function unwrapFromInner(dependencies, inner) {
+  if (dependencies.length === 0 !== "isNotNestedMap" in inner) {
+    return Result.error(void 0);
+  }
+  if ("isNotNestedMap" in inner) {
+    if (dependencies.length === 0) {
+      return Result.ok(inner.value);
+    } else {
+      return Result.error(void 0);
+    }
+  } else {
+    if (dependencies.length === 0) {
+      return Result.error(void 0);
+    } else {
+      const [key, ...rest] = dependencies;
+      const newInner = inner.get(key);
+      if (!newInner) {
+        return Result.error(void 0);
+      }
+      return unwrapFromInner(rest, newInner);
+    }
+  }
+}
+function wrapToInner(dependencies, value) {
+  if (dependencies.length === 0) {
+    return { isNotNestedMap: true, value };
+  }
+  const [key, ...rest] = dependencies;
+  const inner = wrapToInner(rest, value);
+  const isObject = typeof key === "object" && key !== null;
+  const isUnregisteredSymbol = typeof key === "symbol" && Symbol.keyFor(key) === void 0;
+  const isWeak = isObject || isUnregisteredSymbol;
+  const mapType = isWeak ? WeakMap : Map;
+  return new mapType([[key, inner]]);
+}
+function useStrictMemo(callback, dependencies) {
+  const id = useId();
+  useInsertionEffect(() => {
+    return () => {
+      cached.delete(id);
+    };
+  }, [id]);
+  const c = cached.get(id);
+  if (c) {
+    const unwrapped = unwrapFromInner(dependencies, c);
+    if (unwrapped.status === "ok") {
+      return unwrapped.data;
+    }
+  }
+  const value = callback();
+  cached.set(id, wrapToInner(dependencies, value));
+  return value;
+}
+export {
+  useStrictMemo
+};
+//# sourceMappingURL=use-strict-memo.js.map