@agg-build/auth 1.0.0

package/dist/index.js

@@ -0,0 +1,749 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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());
+  });
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AggAuthProvider: () => AggAuthProvider,
+  ConnectButton: () => ConnectButton,
+  createAppleAuthMethod: () => createAppleAuthMethod,
+  createEmailAuthMethod: () => createEmailAuthMethod,
+  createGoogleAuthMethod: () => createGoogleAuthMethod,
+  createTwitterAuthMethod: () => createTwitterAuthMethod,
+  useAggAuthCallback: () => useAggAuthCallback,
+  useAggAuthFlow: () => useAggAuthFlow
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/core/context.tsx
+var import_react = require("react");
+var import_hooks = require("@agg-build/hooks");
+
+// 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}`;
+};
+
+// src/core/methods.ts
+var getAvailableAuthMethods = (methods) => {
+  return methods.filter((method) => method.isAvailable);
+};
+
+// src/core/context.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var AggAuthFlowContext = (0, import_react.createContext)(null);
+var AggAuthProvider = ({
+  autoHandleAuthCallback = true,
+  children,
+  methods
+}) => {
+  const auth = (0, import_hooks.useAggAuthContext)();
+  const handledCallbackRef = (0, import_react.useRef)(false);
+  const [activeMethodId, setActiveMethodId] = (0, import_react.useState)(null);
+  const [selectedMethodId, setSelectedMethodId] = (0, import_react.useState)(null);
+  const [error, setError] = (0, import_react.useState)(null);
+  const [notice, setNotice] = (0, import_react.useState)(null);
+  const [challengeSiteKey, setChallengeSiteKey] = (0, import_react.useState)(null);
+  const pendingMethodIdRef = (0, import_react.useRef)(null);
+  const pendingInputRef = (0, import_react.useRef)(void 0);
+  const challengeTimeoutRef = (0, import_react.useRef)(null);
+  (0, import_react.useEffect)(() => {
+    if (!autoHandleAuthCallback || handledCallbackRef.current) return;
+    handledCallbackRef.current = true;
+    void auth.handleAuthCallback().catch((callbackError) => {
+      setError(normalizeAuthError(toError(callbackError)));
+    });
+  }, [auth, autoHandleAuthCallback]);
+  (0, import_react.useEffect)(() => {
+    if (!auth.isAuthenticated) return;
+    setNotice(null);
+    setChallengeSiteKey(null);
+    pendingMethodIdRef.current = null;
+    pendingInputRef.current = void 0;
+  }, [auth.isAuthenticated]);
+  (0, import_react.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 = (0, import_react.useMemo)(() => {
+    return getAvailableAuthMethods(methods);
+  }, [methods]);
+  const clearFeedback = (0, import_react.useCallback)(() => {
+    setError(null);
+    setNotice(null);
+    setChallengeSiteKey(null);
+    auth.clearError();
+  }, [auth]);
+  const startMethod = (0, import_react.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 import_hooks.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 = (0, import_react.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 = (0, import_react.useCallback)(() => {
+    setChallengeSiteKey(null);
+    pendingMethodIdRef.current = null;
+    pendingInputRef.current = void 0;
+    setError(new Error("Bot protection check failed. Please try again."));
+    setActiveMethodId(null);
+  }, []);
+  const signOut = (0, import_react.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 = (0, import_react.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__ */ (0, import_jsx_runtime.jsx)(AggAuthFlowContext.Provider, { value, children });
+};
+var useAggAuthFlow = () => {
+  const context = (0, import_react.useContext)(AggAuthFlowContext);
+  if (!context) {
+    throw new Error("useAggAuthFlow must be used within an <AggAuthProvider>");
+  }
+  return context;
+};
+
+// src/callback/index.tsx
+var import_react2 = require("react");
+var import_hooks2 = require("@agg-build/hooks");
+var useAggAuthCallback = (options = {}) => {
+  const { callbackUrl, enabled = true } = options;
+  const auth = (0, import_hooks2.useAggAuthContext)();
+  const handledRef = (0, import_react2.useRef)(false);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const [isHandled, setIsHandled] = (0, import_react2.useState)(false);
+  const [isHandling, setIsHandling] = (0, import_react2.useState)(false);
+  const [user, setUser] = (0, import_react2.useState)(null);
+  (0, import_react2.useEffect)(() => {
+    if (!enabled || handledRef.current) return;
+    handledRef.current = true;
+    setIsHandling(true);
+    void auth.handleAuthCallback(callbackUrl).then((resolvedUser) => {
+      setUser(resolvedUser);
+      setIsHandled(resolvedUser !== null);
+    }).catch((callbackError) => {
+      setError(toError(callbackError));
+    }).finally(() => {
+      setIsHandling(false);
+    });
+  }, [auth, callbackUrl, enabled]);
+  return {
+    error,
+    isHandled,
+    isHandling,
+    user
+  };
+};
+
+// src/connect-button/index.tsx
+var import_react4 = require("react");
+var import_ui = require("@agg-build/ui");
+var import_hooks4 = require("@agg-build/hooks");
+
+// src/turnstile/index.tsx
+var import_react3 = require("react");
+var import_react_turnstile = require("@marsidev/react-turnstile");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var TurnstileErrorBoundary = class extends import_react3.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__ */ (0, import_jsx_runtime2.jsx)(TurnstileErrorBoundary, { onError, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+    import_react_turnstile.Turnstile,
+    {
+      siteKey,
+      onSuccess: onVerify,
+      onError,
+      onExpire,
+      options: { appearance: "always", theme: "auto" }
+    }
+  ) });
+};
+
+// src/connect-button/connect-button.utils.ts
+var import_hooks3 = require("@agg-build/hooks");
+var getAuthProfileLabel = (user) => {
+  var _a, _b;
+  if (user == null ? void 0 : user.username) return user.username;
+  const walletAddress = (0, import_hooks3.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
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var ConnectButton = ({
+  buttonProps,
+  classNames,
+  disabled,
+  onAuthMethodSelect,
+  onDepositClick,
+  onDisconnect,
+  onProfileCardClick,
+  onProfileClick,
+  onClaimWinningsClick,
+  claimReadyCount,
+  onWithdrawClick
+}) => {
+  var _a, _b;
+  const [emailValue, setEmailValue] = (0, import_react4.useState)("");
+  const [emailError, setEmailError] = (0, import_react4.useState)(null);
+  const [isChooserOpen, setIsChooserOpen] = (0, import_react4.useState)(false);
+  const [isProfileMenuOpen, setIsProfileMenuOpen] = (0, import_react4.useState)(false);
+  const {
+    activeMethodId,
+    challengeSiteKey,
+    clearFeedback,
+    configuredMethods,
+    error,
+    isBusy,
+    notice,
+    onChallengeError,
+    onChallengeVerify,
+    signOut,
+    startMethod
+  } = useAggAuthFlow();
+  const { isAuthenticated, user } = (0, import_hooks4.useAggAuthContext)();
+  const {
+    totalBalance,
+    positionsBalanceTotal,
+    isLoading: isBalanceLoading,
+    error: balanceError
+  } = (0, import_hooks4.useAggBalanceState)();
+  const { isDepositBlocked } = (0, import_hooks4.useGeoBlock)();
+  const resolvedWalletAddress = (_a = (0, import_hooks4.getWalletAddressFromUserProfile)(user)) != null ? _a : "";
+  const resolvedAddressLabel = resolvedWalletAddress ? shortenAddress(resolvedWalletAddress) : void 0;
+  const resolvedProfileLabel = getAuthProfileLabel(user) || void 0;
+  const { emailMethod, socialMethods, walletMethods } = (0, import_react4.useMemo)(() => {
+    return groupConnectButtonMethods(configuredMethods);
+  }, [configuredMethods]);
+  (0, import_react4.useEffect)(() => {
+    if (!isAuthenticated) return;
+    setIsChooserOpen(false);
+    setEmailError(null);
+  }, [isAuthenticated]);
+  (0, import_react4.useEffect)(() => {
+    if (typeof window === "undefined") return;
+    const handleOpenChooserRequest = () => {
+      if (disabled || isAuthenticated) return;
+      setEmailError(null);
+      clearFeedback();
+      setIsChooserOpen(true);
+    };
+    window.addEventListener(import_hooks4.AUTH_CHOOSER_OPEN_EVENT, handleOpenChooserRequest);
+    return () => {
+      window.removeEventListener(import_hooks4.AUTH_CHOOSER_OPEN_EVENT, handleOpenChooserRequest);
+    };
+  }, [clearFeedback, disabled, isAuthenticated]);
+  const resolvedError = error != null ? error : balanceError;
+  const challengeContent = challengeSiteKey ? /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: "flex flex-col items-center gap-3", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "text-agg-sm text-agg-muted-foreground text-center", children: "Please complete the verification below to continue." }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      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 = (0, import_hooks4.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__ */ (0, import_jsx_runtime3.jsx)(
+    import_ui.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";
+
+// src/email/index.ts
+var import_hooks5 = require("@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 } = (0, import_hooks5.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 import_hooks5.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."
+      };
+    })
+  };
+};
+
+// src/oauth/index.ts
+var defaultNavigate = (url) => {
+  if (typeof window === "undefined") {
+    throw new Error("Redirect auth methods require a browser environment");
+  }
+  window.location.assign(url);
+};
+var createRedirectAuthMethod = (provider, defaults, options = {}) => {
+  var _a, _b, _c;
+  return {
+    id: provider,
+    kind: "social",
+    label: (_a = options.label) != null ? _a : defaults.label,
+    description: (_b = options.description) != null ? _b : defaults.description,
+    iconName: defaults.iconName,
+    isAvailable: (_c = options.isAvailable) != null ? _c : true,
+    start: (_0) => __async(null, [_0], function* ({ startAuth }) {
+      var _a2;
+      const response = yield startAuth({
+        provider,
+        redirectUrl: resolveRedirectUrl(options.redirectUrl)
+      });
+      if (response.type !== "redirect") {
+        throw new Error(`AGG auth start returned an unexpected "${response.type}" response`);
+      }
+      const navigate = (_a2 = options.navigate) != null ? _a2 : defaultNavigate;
+      navigate(response.url);
+    })
+  };
+};
+var createGoogleAuthMethod = (options = {}) => {
+  return createRedirectAuthMethod(
+    "google",
+    {
+      label: "Google",
+      description: "Continue with your Google account.",
+      iconName: "google"
+    },
+    options
+  );
+};
+var createTwitterAuthMethod = (options = {}) => {
+  return createRedirectAuthMethod(
+    "twitter",
+    {
+      label: "X",
+      description: "Continue with your X account.",
+      iconName: "twitter"
+    },
+    options
+  );
+};
+var createAppleAuthMethod = (options = {}) => {
+  return createRedirectAuthMethod(
+    "apple",
+    {
+      label: "Apple",
+      description: "Continue with Apple.",
+      iconName: "apple"
+    },
+    options
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AggAuthProvider,
+  ConnectButton,
+  createAppleAuthMethod,
+  createEmailAuthMethod,
+  createGoogleAuthMethod,
+  createTwitterAuthMethod,
+  useAggAuthCallback,
+  useAggAuthFlow
+});