@agg-build/auth 1.0.0

package/dist/chunk-4RGHFPGG.mjs

@@ -0,0 +1,535 @@
+import {
+  normalizeAuthError,
+  shortenAddress,
+  shortenProfileLabel,
+  toError
+} from "./chunk-BVV6GEOL.mjs";
+import {
+  __async,
+  __spreadProps,
+  __spreadValues
+} from "./chunk-AXBFBHS2.mjs";
+
+// src/connect-button/index.tsx
+import { useEffect as useEffect2, useMemo as useMemo2, useState as useState2 } from "react";
+import { AuthConnectButtonView } from "@agg-build/ui";
+import {
+  AUTH_CHOOSER_OPEN_EVENT,
+  getWalletAddressFromUserProfile as getWalletAddressFromUserProfile2,
+  parseEmail,
+  useAggAuthContext as useAggAuthContext2,
+  useAggBalanceState,
+  useGeoBlock
+} from "@agg-build/hooks";
+
+// src/core/context.tsx
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+import { useAggAuthContext, TurnstileChallengeError } from "@agg-build/hooks";
+
+// src/core/methods.ts
+var getAvailableAuthMethods = (methods) => {
+  return methods.filter((method) => method.isAvailable);
+};
+
+// src/core/context.tsx
+import { jsx } from "react/jsx-runtime";
+var AggAuthFlowContext = createContext(null);
+var AggAuthProvider = ({
+  autoHandleAuthCallback = true,
+  children,
+  methods
+}) => {
+  const auth = useAggAuthContext();
+  const handledCallbackRef = useRef(false);
+  const [activeMethodId, setActiveMethodId] = useState(null);
+  const [selectedMethodId, setSelectedMethodId] = useState(null);
+  const [error, setError] = useState(null);
+  const [notice, setNotice] = useState(null);
+  const [challengeSiteKey, setChallengeSiteKey] = useState(null);
+  const pendingMethodIdRef = useRef(null);
+  const pendingInputRef = useRef(void 0);
+  const challengeTimeoutRef = useRef(null);
+  useEffect(() => {
+    if (!autoHandleAuthCallback || handledCallbackRef.current) return;
+    handledCallbackRef.current = true;
+    void auth.handleAuthCallback().catch((callbackError) => {
+      setError(normalizeAuthError(toError(callbackError)));
+    });
+  }, [auth, autoHandleAuthCallback]);
+  useEffect(() => {
+    if (!auth.isAuthenticated) return;
+    setNotice(null);
+    setChallengeSiteKey(null);
+    pendingMethodIdRef.current = null;
+    pendingInputRef.current = void 0;
+  }, [auth.isAuthenticated]);
+  useEffect(() => {
+    if (challengeTimeoutRef.current) {
+      clearTimeout(challengeTimeoutRef.current);
+      challengeTimeoutRef.current = null;
+    }
+    if (!challengeSiteKey) return;
+    challengeTimeoutRef.current = setTimeout(() => {
+      setChallengeSiteKey(null);
+      pendingMethodIdRef.current = null;
+      pendingInputRef.current = void 0;
+      setError(new Error("Security check timed out. Please try again."));
+      setActiveMethodId(null);
+    }, 15e3);
+    return () => {
+      if (challengeTimeoutRef.current) {
+        clearTimeout(challengeTimeoutRef.current);
+        challengeTimeoutRef.current = null;
+      }
+    };
+  }, [challengeSiteKey]);
+  const availableMethods = useMemo(() => {
+    return getAvailableAuthMethods(methods);
+  }, [methods]);
+  const clearFeedback = useCallback(() => {
+    setError(null);
+    setNotice(null);
+    setChallengeSiteKey(null);
+    auth.clearError();
+  }, [auth]);
+  const startMethod = useCallback(
+    (methodId, input) => __async(null, null, function* () {
+      const method = methods.find((candidate) => candidate.id === methodId);
+      if (!method || !method.isAvailable) {
+        const unavailableError = new Error(`Auth method "${methodId}" is not available`);
+        setError(unavailableError);
+        throw unavailableError;
+      }
+      setError(null);
+      setNotice(null);
+      setActiveMethodId(methodId);
+      setSelectedMethodId(methodId);
+      try {
+        const result = yield method.start(
+          {
+            signIn: auth.signIn,
+            startAuth: auth.startAuth,
+            setSession: auth.setSession
+          },
+          input
+        );
+        if (result == null ? void 0 : result.notice) {
+          setNotice(result.notice);
+        }
+        return {};
+      } catch (startError) {
+        if (startError instanceof TurnstileChallengeError) {
+          pendingMethodIdRef.current = methodId;
+          pendingInputRef.current = input;
+          setChallengeSiteKey(startError.siteKey);
+          setActiveMethodId(null);
+          auth.clearError();
+          return { challengePending: true };
+        }
+        const resolvedError = normalizeAuthError(toError(startError));
+        setError(resolvedError);
+        throw resolvedError;
+      } finally {
+        setActiveMethodId(null);
+      }
+    }),
+    [auth, methods]
+  );
+  const handleTurnstileVerify = useCallback(
+    (token) => __async(null, null, function* () {
+      const methodId = pendingMethodIdRef.current;
+      const input = pendingInputRef.current;
+      if (!methodId) return;
+      setChallengeSiteKey(null);
+      pendingMethodIdRef.current = null;
+      pendingInputRef.current = void 0;
+      const method = methods.find((candidate) => candidate.id === methodId);
+      if (!method || !method.isAvailable) return;
+      setError(null);
+      setActiveMethodId(methodId);
+      try {
+        const result = yield method.start(
+          {
+            signIn: (options) => auth.signIn(__spreadProps(__spreadValues({}, options), { turnstileToken: token })),
+            startAuth: (options) => auth.startAuth(__spreadProps(__spreadValues({}, options), { turnstileToken: token })),
+            setSession: auth.setSession
+          },
+          input
+        );
+        if (result == null ? void 0 : result.notice) {
+          setNotice(result.notice);
+        }
+      } catch (retryError) {
+        setError(normalizeAuthError(toError(retryError)));
+      } finally {
+        setActiveMethodId(null);
+      }
+    }),
+    [auth, methods]
+  );
+  const handleTurnstileError = useCallback(() => {
+    setChallengeSiteKey(null);
+    pendingMethodIdRef.current = null;
+    pendingInputRef.current = void 0;
+    setError(new Error("Bot protection check failed. Please try again."));
+    setActiveMethodId(null);
+  }, []);
+  const signOut = useCallback(() => __async(null, null, function* () {
+    setError(null);
+    setNotice(null);
+    setChallengeSiteKey(null);
+    yield auth.signOut();
+    yield Promise.allSettled(
+      methods.map((method) => __async(null, null, function* () {
+        if (!method.disconnect) return;
+        yield method.disconnect();
+      }))
+    );
+    setSelectedMethodId(null);
+  }), [auth, methods]);
+  const value = useMemo(() => {
+    return {
+      activeMethodId,
+      availableMethods,
+      challengeSiteKey,
+      configuredMethods: methods,
+      error: error != null ? error : auth.error ? normalizeAuthError(auth.error) : null,
+      isBusy: auth.isLoading || activeMethodId !== null,
+      notice,
+      onChallengeError: handleTurnstileError,
+      onChallengeVerify: handleTurnstileVerify,
+      selectedMethodId,
+      startMethod,
+      clearFeedback,
+      signOut
+    };
+  }, [
+    activeMethodId,
+    auth.error,
+    auth.isLoading,
+    availableMethods,
+    challengeSiteKey,
+    clearFeedback,
+    error,
+    handleTurnstileError,
+    handleTurnstileVerify,
+    methods,
+    notice,
+    selectedMethodId,
+    signOut,
+    startMethod
+  ]);
+  return /* @__PURE__ */ jsx(AggAuthFlowContext.Provider, { value, children });
+};
+var useAggAuthFlow = () => {
+  const context = useContext(AggAuthFlowContext);
+  if (!context) {
+    throw new Error("useAggAuthFlow must be used within an <AggAuthProvider>");
+  }
+  return context;
+};
+
+// src/turnstile/index.tsx
+import { Component } from "react";
+import { Turnstile } from "@marsidev/react-turnstile";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var TurnstileErrorBoundary = class extends Component {
+  constructor() {
+    super(...arguments);
+    this.state = { hasError: false };
+  }
+  static getDerivedStateFromError() {
+    return { hasError: true };
+  }
+  componentDidCatch(_error, _info) {
+    var _a, _b;
+    (_b = (_a = this.props).onError) == null ? void 0 : _b.call(_a);
+  }
+  render() {
+    if (this.state.hasError) return null;
+    return this.props.children;
+  }
+};
+var TurnstileWidget = ({
+  siteKey,
+  onVerify,
+  onError,
+  onExpire
+}) => {
+  return /* @__PURE__ */ jsx2(TurnstileErrorBoundary, { onError, children: /* @__PURE__ */ jsx2(
+    Turnstile,
+    {
+      siteKey,
+      onSuccess: onVerify,
+      onError,
+      onExpire,
+      options: { appearance: "always", theme: "auto" }
+    }
+  ) });
+};
+
+// src/connect-button/connect-button.utils.ts
+import { getWalletAddressFromUserProfile } from "@agg-build/hooks";
+var getAuthProfileLabel = (user) => {
+  var _a, _b;
+  if (user == null ? void 0 : user.username) return user.username;
+  const walletAddress = getWalletAddressFromUserProfile(user);
+  if (walletAddress) return shortenAddress(walletAddress);
+  const providerAccountId = (_b = (_a = user == null ? void 0 : user.accounts) == null ? void 0 : _a[0]) == null ? void 0 : _b.providerAccountId;
+  if (providerAccountId) return shortenProfileLabel(providerAccountId);
+  if (user == null ? void 0 : user.id) return shortenProfileLabel(user.id);
+  return "";
+};
+var socialOrder = {
+  google: 0,
+  apple: 1,
+  twitter: 2
+};
+var walletOrder = {
+  siws: 0,
+  siwe: 1
+};
+var toViewMethod = (method) => {
+  return {
+    chain: method.chain,
+    description: method.description,
+    iconName: method.iconName,
+    id: method.id,
+    input: method.input,
+    isAvailable: method.isAvailable,
+    kind: method.kind,
+    label: method.label
+  };
+};
+var groupConnectButtonMethods = (methods) => {
+  var _a;
+  const emailMethod = (_a = methods.find((method) => method.kind === "email")) != null ? _a : null;
+  const socialMethods = methods.filter((method) => method.kind === "social").slice().sort((left, right) => {
+    var _a2, _b;
+    return ((_a2 = socialOrder[left.id]) != null ? _a2 : 99) - ((_b = socialOrder[right.id]) != null ? _b : 99);
+  }).map(toViewMethod);
+  const walletMethods = methods.filter((method) => method.kind === "wallet").slice().sort((left, right) => {
+    var _a2, _b;
+    return ((_a2 = walletOrder[left.id]) != null ? _a2 : 99) - ((_b = walletOrder[right.id]) != null ? _b : 99);
+  }).map(toViewMethod);
+  return {
+    emailMethod: emailMethod ? toViewMethod(emailMethod) : null,
+    socialMethods,
+    walletMethods
+  };
+};
+
+// src/connect-button/index.tsx
+import { jsx as jsx3, jsxs } from "react/jsx-runtime";
+var ConnectButton = ({
+  buttonProps,
+  classNames,
+  disabled,
+  onAuthMethodSelect,
+  onDepositClick,
+  onDisconnect,
+  onProfileCardClick,
+  onProfileClick,
+  onClaimWinningsClick,
+  claimReadyCount,
+  onWithdrawClick
+}) => {
+  var _a, _b;
+  const [emailValue, setEmailValue] = useState2("");
+  const [emailError, setEmailError] = useState2(null);
+  const [isChooserOpen, setIsChooserOpen] = useState2(false);
+  const [isProfileMenuOpen, setIsProfileMenuOpen] = useState2(false);
+  const {
+    activeMethodId,
+    challengeSiteKey,
+    clearFeedback,
+    configuredMethods,
+    error,
+    isBusy,
+    notice,
+    onChallengeError,
+    onChallengeVerify,
+    signOut,
+    startMethod
+  } = useAggAuthFlow();
+  const { isAuthenticated, user } = useAggAuthContext2();
+  const {
+    totalBalance,
+    positionsBalanceTotal,
+    isLoading: isBalanceLoading,
+    error: balanceError
+  } = useAggBalanceState();
+  const { isDepositBlocked } = useGeoBlock();
+  const resolvedWalletAddress = (_a = getWalletAddressFromUserProfile2(user)) != null ? _a : "";
+  const resolvedAddressLabel = resolvedWalletAddress ? shortenAddress(resolvedWalletAddress) : void 0;
+  const resolvedProfileLabel = getAuthProfileLabel(user) || void 0;
+  const { emailMethod, socialMethods, walletMethods } = useMemo2(() => {
+    return groupConnectButtonMethods(configuredMethods);
+  }, [configuredMethods]);
+  useEffect2(() => {
+    if (!isAuthenticated) return;
+    setIsChooserOpen(false);
+    setEmailError(null);
+  }, [isAuthenticated]);
+  useEffect2(() => {
+    if (typeof window === "undefined") return;
+    const handleOpenChooserRequest = () => {
+      if (disabled || isAuthenticated) return;
+      setEmailError(null);
+      clearFeedback();
+      setIsChooserOpen(true);
+    };
+    window.addEventListener(AUTH_CHOOSER_OPEN_EVENT, handleOpenChooserRequest);
+    return () => {
+      window.removeEventListener(AUTH_CHOOSER_OPEN_EVENT, handleOpenChooserRequest);
+    };
+  }, [clearFeedback, disabled, isAuthenticated]);
+  const resolvedError = error != null ? error : balanceError;
+  const challengeContent = challengeSiteKey ? /* @__PURE__ */ jsxs("div", { className: "flex flex-col items-center gap-3", children: [
+    /* @__PURE__ */ jsx3("p", { className: "text-agg-sm text-agg-muted-foreground text-center", children: "Please complete the verification below to continue." }),
+    /* @__PURE__ */ jsx3(
+      TurnstileWidget,
+      {
+        siteKey: challengeSiteKey,
+        onVerify: onChallengeVerify,
+        onError: onChallengeError,
+        onExpire: onChallengeError
+      }
+    )
+  ] }) : null;
+  const handleMethodSelection = (method) => __async(null, null, function* () {
+    if (!method.isAvailable || disabled || isBusy) return;
+    setEmailError(null);
+    clearFeedback();
+    setIsChooserOpen(false);
+    let result;
+    try {
+      result = yield startMethod(method.id);
+    } catch (e) {
+      setIsChooserOpen(true);
+      return;
+    }
+    if (result == null ? void 0 : result.challengePending) return;
+    yield Promise.resolve(onAuthMethodSelect == null ? void 0 : onAuthMethodSelect(method.id));
+    setIsChooserOpen(false);
+  });
+  const handleEmailSubmit = () => __async(null, null, function* () {
+    var _a2, _b2, _c;
+    if (!emailMethod || !emailMethod.isAvailable || disabled || isBusy) return;
+    const parsedEmail = parseEmail(emailValue);
+    if (!parsedEmail.success) {
+      setEmailError((_c = (_b2 = (_a2 = parsedEmail.error) == null ? void 0 : _a2.issues[0]) == null ? void 0 : _b2.message) != null ? _c : "Enter a valid email address.");
+      return;
+    }
+    setEmailError(null);
+    const result = yield startMethod(emailMethod.id, {
+      email: parsedEmail.data.email
+    });
+    if (result == null ? void 0 : result.challengePending) return;
+    yield Promise.resolve(onAuthMethodSelect == null ? void 0 : onAuthMethodSelect(emailMethod.id));
+    setEmailValue("");
+    setIsChooserOpen(false);
+  });
+  const handleDepositClick = () => {
+    if (disabled) return;
+    setIsProfileMenuOpen(false);
+    void Promise.resolve(onDepositClick == null ? void 0 : onDepositClick());
+  };
+  const handleProfileCardClick = () => {
+    if (disabled) return;
+    setIsProfileMenuOpen(false);
+    void Promise.resolve(onProfileCardClick == null ? void 0 : onProfileCardClick());
+  };
+  const handleProfileClick = () => {
+    if (disabled) return;
+    setIsProfileMenuOpen(false);
+    void Promise.resolve(onProfileClick == null ? void 0 : onProfileClick());
+  };
+  const handleClaimWinningsClick = () => {
+    if (disabled) return;
+    setIsProfileMenuOpen(false);
+    void Promise.resolve(onClaimWinningsClick == null ? void 0 : onClaimWinningsClick());
+  };
+  const handleWithdrawClick = () => {
+    if (disabled) return;
+    setIsProfileMenuOpen(false);
+    void Promise.resolve(onWithdrawClick == null ? void 0 : onWithdrawClick());
+  };
+  const handleDisconnectClick = () => __async(null, null, function* () {
+    if (disabled) return;
+    setIsProfileMenuOpen(false);
+    yield signOut();
+    yield Promise.resolve(onDisconnect == null ? void 0 : onDisconnect());
+  });
+  const handleChooserOpenChange = (open) => {
+    if (disabled) return;
+    setIsChooserOpen(open);
+    if (open) return;
+    setEmailError(null);
+    clearFeedback();
+  };
+  return /* @__PURE__ */ jsx3(
+    AuthConnectButtonView,
+    {
+      activeMethodId,
+      addressLabel: resolvedAddressLabel,
+      buttonProps,
+      challengeContent,
+      classNames,
+      disabled,
+      emailMethod,
+      emailError,
+      emailValue,
+      errorMessage: (_b = resolvedError == null ? void 0 : resolvedError.message) != null ? _b : null,
+      isAuthenticated,
+      isBalanceLoading,
+      isBusy,
+      isChooserOpen,
+      isProfileMenuOpen,
+      notice,
+      onChooserOpenChange: handleChooserOpenChange,
+      onDepositClick: handleDepositClick,
+      onDisconnectClick: () => {
+        void handleDisconnectClick();
+      },
+      onEmailChange: setEmailValue,
+      onEmailSubmit: () => {
+        void handleEmailSubmit();
+      },
+      onMethodSelect: (methodId) => {
+        const selectedMethod = [...socialMethods, ...walletMethods].find(
+          (method) => method.id === methodId
+        );
+        if (!selectedMethod) return;
+        void handleMethodSelection(selectedMethod);
+      },
+      onProfileCardClick: handleProfileCardClick,
+      onProfileClick: handleProfileClick,
+      onProfileMenuOpenChange: setIsProfileMenuOpen,
+      socialMethods,
+      onWithdrawClick: handleWithdrawClick,
+      profileLabel: resolvedProfileLabel,
+      totalBalance,
+      positionsBalance: positionsBalanceTotal,
+      claimReadyCount,
+      onClaimWinningsClick: handleClaimWinningsClick,
+      walletMethods,
+      isDepositBlocked
+    }
+  );
+};
+ConnectButton.displayName = "ConnectButton";
+
+export {
+  AggAuthProvider,
+  useAggAuthFlow,
+  ConnectButton
+};

package/dist/chunk-AXBFBHS2.mjs

@@ -0,0 +1,45 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+export {
+  __spreadValues,
+  __spreadProps,
+  __async
+};

package/dist/chunk-BVV6GEOL.mjs

@@ -0,0 +1,36 @@
+// src/shared/utils.ts
+var toError = (value) => {
+  return value instanceof Error ? value : new Error(String(value));
+};
+var normalizeAuthError = (error) => {
+  const lower = error.message.toLowerCase();
+  if (lower.includes("user rejected") || lower.includes("user denied") || lower.includes("rejected the request") || lower.includes("denied transaction signature")) {
+    return new Error("Wallet request rejected.");
+  }
+  return error;
+};
+var shortenAddress = (value) => {
+  if (value.length < 10) return value;
+  if (value.startsWith("0x")) return `${value.slice(0, 6)}...${value.slice(-4)}`;
+  return `${value.slice(0, 4)}...${value.slice(-4)}`;
+};
+var shortenProfileLabel = (value) => {
+  if (!value) return value;
+  if (value.includes("@")) return value;
+  if (value.startsWith("0x")) return shortenAddress(value);
+  if (value.length <= 16) return value;
+  return `${value.slice(0, 8)}...${value.slice(-5)}`;
+};
+var resolveRedirectUrl = (redirectUrl) => {
+  if (redirectUrl) return redirectUrl;
+  if (typeof window === "undefined") return "http://localhost";
+  return `${window.location.origin}${window.location.pathname}${window.location.search}`;
+};
+
+export {
+  toError,
+  normalizeAuthError,
+  shortenAddress,
+  shortenProfileLabel,
+  resolveRedirectUrl
+};

package/dist/chunk-FGEWDEEE.mjs

@@ -0,0 +1,51 @@
+import {
+  resolveRedirectUrl
+} from "./chunk-BVV6GEOL.mjs";
+import {
+  __async
+} from "./chunk-AXBFBHS2.mjs";
+
+// src/email/index.ts
+import { parseEmailStrict, TurnstileChallengeError } from "@agg-build/hooks";
+var createEmailAuthMethod = (options = {}) => {
+  var _a, _b, _c, _d, _e;
+  return {
+    id: "email",
+    kind: "email",
+    label: (_a = options.label) != null ? _a : "Email",
+    description: (_b = options.description) != null ? _b : "Get a magic link sent to your inbox.",
+    iconName: "email",
+    input: {
+      type: "email",
+      placeholder: (_c = options.placeholder) != null ? _c : "Email address",
+      submitLabel: (_d = options.submitLabel) != null ? _d : "Continue",
+      helperText: options.helperText
+    },
+    isAvailable: (_e = options.isAvailable) != null ? _e : true,
+    start: (_0, _1) => __async(null, [_0, _1], function* ({ startAuth }, input) {
+      var _a2, _b2;
+      const { email } = parseEmailStrict((_a2 = input == null ? void 0 : input.email) != null ? _a2 : "");
+      const response = yield startAuth({
+        provider: "email",
+        email,
+        redirectUrl: resolveRedirectUrl(options.redirectUrl)
+      });
+      if (response.type === "challenge_required") {
+        if (!response.siteKey) {
+          throw new Error("Server returned challenge_required but no siteKey was provided.");
+        }
+        throw new TurnstileChallengeError(response.siteKey);
+      }
+      if (response.type !== "magic_link") {
+        throw new Error(`AGG auth start returned an unexpected "${response.type}" response`);
+      }
+      return {
+        notice: (_b2 = options.successNotice) != null ? _b2 : "Check your email for a magic link to finish signing in."
+      };
+    })
+  };
+};
+
+export {
+  createEmailAuthMethod
+};