@authowl/react 0.19.1 → 0.20.0

package/dist/chunk-DPWUE5HS.js

@@ -0,0 +1,921 @@
+// src/brand.ts
+var DEFAULT_BRAND_COLOR = "#F5B84C";
+var HEX6 = /^#[0-9a-fA-F]{6}$/;
+function isHex6(value) {
+  return typeof value === "string" && HEX6.test(value);
+}
+function normalizeHex(value) {
+  return isHex6(value) ? value.toLowerCase() : null;
+}
+function srgbToLinear(c) {
+  return c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+}
+function linearToSrgb(l) {
+  return l <= 31308e-7 ? 12.92 * l : 1.055 * Math.pow(l, 1 / 2.4) - 0.055;
+}
+function hexToRgb(hex) {
+  const n = parseInt(hex.slice(1), 16);
+  return {
+    r: (n >> 16 & 255) / 255,
+    g: (n >> 8 & 255) / 255,
+    b: (n & 255) / 255
+  };
+}
+function clamp01(x) {
+  return x < 0 ? 0 : x > 1 ? 1 : x;
+}
+function rgbToHex({ r, g, b }) {
+  const to = (c) => Math.round(clamp01(c) * 255).toString(16).padStart(2, "0");
+  return `#${to(r)}${to(g)}${to(b)}`;
+}
+function rgbToOklch({ r, g, b }) {
+  const lr = srgbToLinear(r);
+  const lg = srgbToLinear(g);
+  const lb = srgbToLinear(b);
+  const l = 0.4122214708 * lr + 0.5363325363 * lg + 0.0514459929 * lb;
+  const m = 0.2119034982 * lr + 0.6806995451 * lg + 0.1073969566 * lb;
+  const s = 0.0883024619 * lr + 0.2817188376 * lg + 0.6299787005 * lb;
+  const l_ = Math.cbrt(l);
+  const m_ = Math.cbrt(m);
+  const s_ = Math.cbrt(s);
+  const L = 0.2104542553 * l_ + 0.793617785 * m_ - 0.0040720468 * s_;
+  const a = 1.9779984951 * l_ - 2.428592205 * m_ + 0.4505937099 * s_;
+  const bb = 0.0259040371 * l_ + 0.7827717662 * m_ - 0.808675766 * s_;
+  return { L, C: Math.hypot(a, bb), h: Math.atan2(bb, a) };
+}
+function oklchToLinearRgb({ L, C, h }) {
+  const a = C * Math.cos(h);
+  const b = C * Math.sin(h);
+  const l_ = L + 0.3963377774 * a + 0.2158037573 * b;
+  const m_ = L - 0.1055613458 * a - 0.0638541728 * b;
+  const s_ = L - 0.0894841775 * a - 1.291485548 * b;
+  const l = l_ * l_ * l_;
+  const m = m_ * m_ * m_;
+  const s = s_ * s_ * s_;
+  return {
+    r: 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,
+    g: -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,
+    b: -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s
+  };
+}
+var GAMUT_EPS = 1e-4;
+function inGamut({ r, g, b }) {
+  return r >= -GAMUT_EPS && r <= 1 + GAMUT_EPS && g >= -GAMUT_EPS && g <= 1 + GAMUT_EPS && b >= -GAMUT_EPS && b <= 1 + GAMUT_EPS;
+}
+function oklchToHex(color) {
+  const linear = oklchToLinearRgb(color);
+  if (inGamut(linear)) return rgbToHex(linearToGamma(linear));
+  let lo = 0;
+  let hi = color.C;
+  for (let i = 0; i < 24; i++) {
+    const mid = (lo + hi) / 2;
+    if (inGamut(oklchToLinearRgb({ ...color, C: mid }))) lo = mid;
+    else hi = mid;
+  }
+  return rgbToHex(linearToGamma(oklchToLinearRgb({ ...color, C: lo })));
+}
+function linearToGamma({ r, g, b }) {
+  return {
+    r: linearToSrgb(clamp01(r)),
+    g: linearToSrgb(clamp01(g)),
+    b: linearToSrgb(clamp01(b))
+  };
+}
+function relativeLuminance({ r, g, b }) {
+  return 0.2126 * srgbToLinear(r) + 0.7152 * srgbToLinear(g) + 0.0722 * srgbToLinear(b);
+}
+function contrastRatio(hexA, hexB) {
+  const la = relativeLuminance(hexToRgb(hexA));
+  const lb = relativeLuminance(hexToRgb(hexB));
+  const [hi, lo] = la >= lb ? [la, lb] : [lb, la];
+  return (hi + 0.05) / (lo + 0.05);
+}
+var NEAR_BLACK = "#18181b";
+var WHITE = "#ffffff";
+var AA_TEXT = 4.5;
+var PURE_BLACK = "#000000";
+function readableForeground(solidHex) {
+  const white = contrastRatio(WHITE, solidHex);
+  const nearBlack = contrastRatio(NEAR_BLACK, solidHex);
+  const best = Math.max(white, nearBlack);
+  if (best >= AA_TEXT) return white >= nearBlack ? WHITE : NEAR_BLACK;
+  return contrastRatio(WHITE, solidHex) >= contrastRatio(PURE_BLACK, solidHex) ? WHITE : PURE_BLACK;
+}
+function shiftLightness(baseHex, dl) {
+  const { L, C, h } = rgbToOklch(hexToRgb(baseHex));
+  return oklchToHex({ L: clamp01(L + dl), C, h });
+}
+function readableAccent(brandHex, surfaceHex, dir) {
+  const { L, C, h } = rgbToOklch(hexToRgb(brandHex));
+  for (let i = 0; i <= 50; i++) {
+    const stepL = L + dir * 0.02 * i;
+    if (stepL < 0 || stepL > 1) break;
+    const candidate = oklchToHex({ L: stepL, C, h });
+    if (contrastRatio(candidate, surfaceHex) >= AA_TEXT) return candidate;
+  }
+  return dir === 1 ? WHITE : NEAR_BLACK;
+}
+var LIGHT_SURFACE = "#ffffff";
+var DARK_SURFACE = "#18181b";
+function deriveBrandRamp(primaryHex) {
+  const solid = normalizeHex(primaryHex) ?? DEFAULT_BRAND_COLOR.toLowerCase();
+  const fg = readableForeground(solid);
+  return {
+    light: {
+      accentSolid: solid,
+      accentSolidHover: shiftLightness(solid, -0.06),
+      accentSolidActive: shiftLightness(solid, -0.1),
+      accentFg: fg,
+      accent: readableAccent(solid, LIGHT_SURFACE, -1)
+    },
+    dark: {
+      accentSolid: solid,
+      accentSolidHover: shiftLightness(solid, 0.06),
+      accentSolidActive: shiftLightness(solid, 0.1),
+      accentFg: fg,
+      accent: readableAccent(solid, DARK_SURFACE, 1)
+    }
+  };
+}
+function brandRampVars(set) {
+  return {
+    "--ba-rt-solid-hover-l": set.light.accentSolidHover,
+    "--ba-rt-solid-hover-d": set.dark.accentSolidHover,
+    "--ba-rt-solid-active-l": set.light.accentSolidActive,
+    "--ba-rt-solid-active-d": set.dark.accentSolidActive,
+    "--ba-rt-accent-l": set.light.accent,
+    "--ba-rt-accent-d": set.dark.accent,
+    // Foreground is chosen against the solid fill, which is theme-independent.
+    "--ba-rt-accent-fg": set.light.accentFg
+  };
+}
+
+// src/hooks.ts
+import * as React5 from "react";
+import {
+  clearInvitationClaim,
+  createMembershipHas,
+  readInvitationClaim
+} from "@authowl/core";
+
+// src/provider.tsx
+import * as React4 from "react";
+import {
+  captureInvitationClaim,
+  createAuthOwlClient,
+  directionFor,
+  getPublicConfig,
+  isLocale,
+  resolveConfig
+} from "@authowl/core";
+
+// src/appearance.ts
+function resolveAppearance(appearance, config) {
+  const theme = appearance?.theme ?? config?.branding?.theme ?? "light";
+  const primaryColor = appearance?.primaryColor ?? config?.branding?.primaryColor;
+  const style = {};
+  if (primaryColor) {
+    style["--ba-primary"] = primaryColor;
+    const hex = normalizeHex(primaryColor);
+    if (hex) Object.assign(style, brandRampVars(deriveBrandRamp(hex)));
+  }
+  return { theme, primaryColor, style };
+}
+
+// src/components/InvitationPrompt.tsx
+import * as React3 from "react";
+
+// src/i18n/index.tsx
+import * as React from "react";
+import {
+  formatMessage,
+  resolveServerError
+} from "@authowl/core/i18n";
+import {
+  formatMessage as formatMessage2,
+  serverErrorMessage,
+  resolveServerError as resolveServerError2,
+  formatRetryDuration,
+  catalogs
+} from "@authowl/core/i18n";
+import { jsx } from "react/jsx-runtime";
+function useLocale() {
+  return useAuthOwlContext().locale;
+}
+function useT() {
+  const locale = useLocale();
+  return React.useCallback(
+    (key, params) => formatMessage(locale, key, params),
+    [locale]
+  );
+}
+function richMessage(template, slots) {
+  return template.split(/(\{\w+\})/g).filter(Boolean).map((part, i) => {
+    const token = /^\{(\w+)\}$/.exec(part);
+    if (token && token[1] in slots) {
+      return /* @__PURE__ */ jsx(React.Fragment, { children: slots[token[1]] }, i);
+    }
+    return part;
+  });
+}
+function Bidi({ children }) {
+  return /* @__PURE__ */ jsx("bdi", { children });
+}
+function useServerError() {
+  const locale = useLocale();
+  return React.useCallback(
+    (error, fallback) => resolveServerError(locale, error, fallback),
+    [locale]
+  );
+}
+
+// src/components/ModalSurface.tsx
+import * as React2 from "react";
+import { createPortal } from "react-dom";
+import { Fragment as Fragment2, jsx as jsx2, jsxs } from "react/jsx-runtime";
+var useClientLayoutEffect = typeof document === "undefined" ? React2.useEffect : React2.useLayoutEffect;
+function ModalSurface({
+  overlayClassName,
+  panelClassName,
+  labelledBy,
+  testId,
+  returnFocusRef,
+  onClose,
+  children
+}) {
+  const ownerRef = React2.useRef(null);
+  const panelRef = React2.useRef(null);
+  const [portalTarget, setPortalTarget] = React2.useState(null);
+  const onCloseRef = React2.useRef(onClose);
+  const returnFocusRefRef = React2.useRef(returnFocusRef);
+  onCloseRef.current = onClose;
+  returnFocusRefRef.current = returnFocusRef;
+  useClientLayoutEffect(() => {
+    setPortalTarget(ownerRef.current?.closest(".authowl-root") ?? document.body);
+  }, []);
+  React2.useEffect(() => {
+    if (!portalTarget) return;
+    const previousFocus = document.activeElement instanceof HTMLElement ? document.activeElement : null;
+    const previousOverflow = document.body.style.overflow;
+    document.body.style.overflow = "hidden";
+    const onKeyDown = (event) => {
+      if (event.key === "Escape") {
+        event.preventDefault();
+        onCloseRef.current();
+        return;
+      }
+      if (event.key !== "Tab" || !panelRef.current) return;
+      const focusable = [...panelRef.current.querySelectorAll(
+        'button:not([disabled]), input:not([disabled]), select:not([disabled]), textarea:not([disabled]), a[href], [tabindex]:not([tabindex="-1"])'
+      )];
+      if (focusable.length === 0) return;
+      const first = focusable[0];
+      const last = focusable[focusable.length - 1];
+      if (event.shiftKey && document.activeElement === first) {
+        event.preventDefault();
+        last.focus();
+      } else if (!event.shiftKey && document.activeElement === last) {
+        event.preventDefault();
+        first.focus();
+      }
+    };
+    document.addEventListener("keydown", onKeyDown);
+    return () => {
+      document.body.style.overflow = previousOverflow;
+      document.removeEventListener("keydown", onKeyDown);
+      const returnTarget = returnFocusRefRef.current?.current ?? previousFocus;
+      window.setTimeout(() => returnTarget?.focus(), 0);
+    };
+  }, [portalTarget]);
+  const surface = /* @__PURE__ */ jsx2("div", { className: overlayClassName, role: "presentation", onMouseDown: (event) => {
+    if (event.target === event.currentTarget) onClose();
+  }, children: /* @__PURE__ */ jsx2(
+    "div",
+    {
+      ref: panelRef,
+      className: panelClassName,
+      role: "dialog",
+      "aria-modal": "true",
+      "aria-labelledby": labelledBy,
+      "data-testid": testId,
+      children
+    }
+  ) });
+  return /* @__PURE__ */ jsxs(Fragment2, { children: [
+    /* @__PURE__ */ jsx2("span", { ref: ownerRef, hidden: true, "aria-hidden": "true" }),
+    portalTarget ? createPortal(surface, portalTarget) : null
+  ] });
+}
+
+// src/components/InvitationPrompt.tsx
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+function InvitationPrompt() {
+  const t = useT();
+  const { invitation, status, accept, dismiss } = useOrganizationInvitation();
+  const { signOut } = useSignOut();
+  const headingId = React3.useId();
+  if (status === "idle" || status === "loading") return null;
+  const message = (() => {
+    switch (status) {
+      case "wrong_account":
+        return t("organization.invitationPrompt.error.wrongAccount");
+      case "verify_email":
+        return t("organization.invitationPrompt.error.verifyEmail");
+      case "gone":
+        return t("organization.invitationPrompt.error.gone");
+      case "error":
+        return t("organization.invitationPrompt.error.generic");
+      default:
+        return null;
+    }
+  })();
+  const joining = status === "joining";
+  const canAccept = status === "ready" || status === "error" || joining;
+  return /* @__PURE__ */ jsxs2(
+    ModalSurface,
+    {
+      overlayClassName: "ba-invitation-overlay",
+      panelClassName: "ba-invitation-panel",
+      labelledBy: headingId,
+      testId: "authowl-invitation-prompt",
+      onClose: dismiss,
+      children: [
+        /* @__PURE__ */ jsx3("h2", { id: headingId, className: "ba-title", children: t("organization.invitationPrompt.title") }),
+        invitation ? /* @__PURE__ */ jsx3("p", { className: "ba-subtitle", children: t("organization.invitationPrompt.body", { organization: invitation.organizationName }) }) : null,
+        message ? /* @__PURE__ */ jsx3("p", { className: "ba-error", role: "alert", children: message }) : null,
+        /* @__PURE__ */ jsxs2("div", { className: "ba-invitation-actions", children: [
+          canAccept ? /* @__PURE__ */ jsx3(
+            "button",
+            {
+              type: "button",
+              className: "ba-button",
+              onClick: () => void accept(),
+              disabled: joining,
+              children: joining ? t("organization.invitationPrompt.joining") : t("organization.invitationPrompt.accept")
+            }
+          ) : null,
+          status === "wrong_account" ? (
+            // Deliberately keeps the claim: the invitation is still live and still
+            // theirs to accept from the right account, so it must survive the
+            // sign-out and reappear after they sign back in.
+            /* @__PURE__ */ jsx3("button", { type: "button", className: "ba-button ba-button-secondary", onClick: () => void signOut(), children: t("organization.invitationPrompt.signOut") })
+          ) : null,
+          /* @__PURE__ */ jsx3("button", { type: "button", className: "ba-button ba-button-secondary", onClick: dismiss, children: t("organization.invitationPrompt.dismiss") })
+        ] })
+      ]
+    }
+  );
+}
+
+// src/provider.tsx
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var warnedConfigProjects = /* @__PURE__ */ new Set();
+function warnPublicConfigFailed(resolved, error) {
+  let origin = resolved.apiUrl;
+  try {
+    origin = new URL(resolved.apiUrl).origin;
+  } catch {
+  }
+  const key = `${origin}:${resolved.decoded.projectId}`;
+  if (warnedConfigProjects.has(key)) return;
+  warnedConfigProjects.add(key);
+  const reason = error instanceof Error ? error.message : String(error);
+  console.warn(
+    `[AuthOwl] Could not load this project's public config from ${origin} (${reason}). Falling back to a password-only sign-in form, regardless of the methods this project actually enabled. Likely causes: the API is unreachable, \`apiUrl\` is wrong, or the publishable key points at a missing/mismatched project. If password sign-in is not enabled for this project, the form will dead-end at submit - check \`apiUrl\` and \`publishableKey\` on <AuthOwlProvider>. (This warning is dev-only.)`
+  );
+}
+var Context = React4.createContext(null);
+function detectLocale() {
+  if (typeof document !== "undefined") {
+    const root = document.documentElement;
+    if (root.lang?.toLowerCase().startsWith("ar") || root.dir === "rtl") return "ar";
+  }
+  if (typeof navigator !== "undefined" && navigator.language?.toLowerCase().startsWith("ar")) {
+    return "ar";
+  }
+  return "en";
+}
+function resolveLocale(prop, autoDetected, configLocale) {
+  if (prop !== "auto" && isLocale(prop)) return prop;
+  if (prop === "auto") return autoDetected ?? "en";
+  return isLocale(configLocale) ? configLocale : "en";
+}
+function AuthOwlProvider({
+  publishableKey,
+  apiUrl,
+  fetch,
+  appearance,
+  locale: localeProp,
+  invitationPrompt = true,
+  children
+}) {
+  const fetchRef = React4.useRef(fetch);
+  fetchRef.current = fetch;
+  const resolved = React4.useMemo(
+    () => resolveConfig({ publishableKey, apiUrl, fetch: fetchRef.current }),
+    [publishableKey, apiUrl]
+  );
+  const client = React4.useMemo(() => createAuthOwlClient(resolved), [resolved]);
+  const [config, setConfig] = React4.useState(null);
+  const [configState, setConfigState] = React4.useState("loading");
+  React4.useEffect(() => {
+    let active = true;
+    setConfigState("loading");
+    getPublicConfig(resolved).then((c) => {
+      if (!active) return;
+      setConfig(c);
+      setConfigState("ready");
+    }).catch((err) => {
+      if (!active) return;
+      setConfig(null);
+      setConfigState("error");
+      if (process.env.NODE_ENV !== "production") warnPublicConfigFailed(resolved, err);
+    });
+    return () => {
+      active = false;
+    };
+  }, [resolved]);
+  const merged = resolveAppearance(appearance, config);
+  const [autoLocale, setAutoLocale] = React4.useState(null);
+  React4.useEffect(() => {
+    if (localeProp === "auto") setAutoLocale(detectLocale());
+  }, [localeProp]);
+  const locale = resolveLocale(localeProp, autoLocale, config?.locale);
+  React4.useEffect(() => {
+    captureInvitationClaim();
+  }, []);
+  const ctxValue = React4.useMemo(
+    () => ({ client, appearance, config, configState, locale }),
+    [client, appearance, config, configState, locale]
+  );
+  return /* @__PURE__ */ jsx4(Context.Provider, { value: ctxValue, children: /* @__PURE__ */ jsxs3(
+    "div",
+    {
+      className: "authowl-root",
+      "data-authowl-theme": merged.theme,
+      "data-authowl-locale": locale,
+      dir: directionFor(locale),
+      style: { display: "contents", ...merged.style },
+      children: [
+        children,
+        invitationPrompt ? /* @__PURE__ */ jsx4(InvitationPrompt, {}) : null
+      ]
+    }
+  ) });
+}
+function useAuthOwlContext() {
+  const v = React4.useContext(Context);
+  if (!v) {
+    throw new Error("AuthOwl hooks must be used inside <AuthOwlProvider>");
+  }
+  return v;
+}
+
+// src/components/auth-state.ts
+function sessionAuthState(data) {
+  const hasUser = !!data?.user;
+  const pending = data?.session?.pendingMfaEnrollment === true;
+  return {
+    isSignedIn: hasUser && !pending,
+    needsMfaEnrollment: hasUser && pending
+  };
+}
+
+// src/hooks.ts
+function useAuthClient() {
+  return useAuthOwlContext().client;
+}
+function useAccount() {
+  return useAuthClient().account;
+}
+function usePublicConfig() {
+  const { config, configState } = useAuthOwlContext();
+  return {
+    config,
+    isLoading: configState === "loading",
+    isError: configState === "error"
+  };
+}
+function useSession() {
+  const client = useAuthClient();
+  return React5.useSyncExternalStore(
+    client.sessionStore.subscribe,
+    client.sessionStore.getSnapshot,
+    client.sessionStore.getSnapshot
+  );
+}
+function useUser() {
+  const { data, isPending, error } = useSession();
+  const state = sessionAuthState(data);
+  return {
+    user: data?.user ?? null,
+    isLoaded: !isPending,
+    isSignedIn: state.isSignedIn,
+    needsMfaEnrollment: state.needsMfaEnrollment,
+    error: error ?? null
+  };
+}
+function useAuth() {
+  const client = useAuthClient();
+  const { data, isPending } = useSession();
+  return {
+    isLoaded: !isPending,
+    isSignedIn: sessionAuthState(data).isSignedIn,
+    userId: data?.user?.id ?? null,
+    orgId: data?.session?.activeOrganizationId ?? null,
+    getToken: client.getToken
+  };
+}
+function useOrganization() {
+  const client = useAuthClient();
+  const apiRef = React5.useRef(client.organization);
+  apiRef.current = client.organization;
+  const { data, isPending } = useSession();
+  const membership = data?.session?.membership ?? null;
+  const activeOrganizationId = data?.session?.activeOrganizationId ?? null;
+  const identity = data?.user?.id ?? null;
+  const [organization, setOrganization] = React5.useState(null);
+  const [orgLoaded, setOrgLoaded] = React5.useState(false);
+  const requestRef = React5.useRef(0);
+  React5.useEffect(() => {
+    const token = ++requestRef.current;
+    setOrganization(null);
+    setOrgLoaded(false);
+    if (isPending) return;
+    if (!identity || !activeOrganizationId) {
+      setOrgLoaded(true);
+      return;
+    }
+    void (async () => {
+      try {
+        const result = await apiRef.current.get({ organizationId: activeOrganizationId });
+        if (token !== requestRef.current) return;
+        setOrganization(result.data ?? null);
+      } catch {
+        if (token === requestRef.current) setOrganization(null);
+      } finally {
+        if (token === requestRef.current) setOrgLoaded(true);
+      }
+    })();
+    return () => {
+      requestRef.current += 1;
+    };
+  }, [identity, activeOrganizationId, isPending]);
+  const bound = React5.useMemo(() => createMembershipHas(membership), [membership]);
+  return {
+    organization,
+    membership,
+    teams: membership?.teams ?? [],
+    // AuthOwl nulls this server-side when the stored pointer names a team the
+    // member no longer holds, so it never needs re-validating here.
+    activeTeamId: data?.session?.activeTeamId ?? null,
+    has: bound.has,
+    hasPermission: bound.hasPermission,
+    isLoaded: !isPending && orgLoaded
+  };
+}
+function useOrganizationInvitation() {
+  const client = useAuthClient();
+  const apiRef = React5.useRef(client.organization);
+  apiRef.current = client.organization;
+  const { data, isPending } = useSession();
+  const identity = data?.user?.id ?? null;
+  const [claim, setClaim] = React5.useState(null);
+  const [invitation, setInvitation] = React5.useState(null);
+  const [status, setStatus] = React5.useState("idle");
+  const requestRef = React5.useRef(0);
+  React5.useEffect(() => {
+    setClaim(readInvitationClaim());
+  }, [identity]);
+  React5.useEffect(() => {
+    const token = ++requestRef.current;
+    if (isPending || !claim) return;
+    if (!identity) {
+      setStatus("idle");
+      return;
+    }
+    setStatus("loading");
+    void (async () => {
+      const result = await apiRef.current.getInvitation({ id: claim.id });
+      if (token !== requestRef.current) return;
+      if (result.data) {
+        setInvitation(result.data);
+        setStatus("ready");
+        return;
+      }
+      setInvitation(null);
+      setStatus(result.error?.code === "YOU_ARE_NOT_THE_RECIPIENT_OF_THE_INVITATION" ? "wrong_account" : "gone");
+    })();
+    return () => {
+      requestRef.current += 1;
+    };
+  }, [claim, identity, isPending]);
+  const accept = React5.useCallback(async () => {
+    const current = readInvitationClaim();
+    if (!current) return false;
+    setStatus("joining");
+    const result = await apiRef.current.acceptInvitation({ invitationId: current.id });
+    if (result.data) {
+      clearInvitationClaim();
+      setClaim(null);
+      setStatus("idle");
+      return true;
+    }
+    const code = result.error?.code;
+    if (code === "YOU_ARE_NOT_THE_RECIPIENT_OF_THE_INVITATION") setStatus("wrong_account");
+    else if (code !== void 0 && code.startsWith("EMAIL_VERIFICATION_REQUIRED")) {
+      setStatus("verify_email");
+    } else if (code === "INVITATION_NOT_FOUND") {
+      clearInvitationClaim();
+      setClaim(null);
+      setStatus("gone");
+    } else setStatus("error");
+    return false;
+  }, []);
+  const dismiss = React5.useCallback(() => {
+    clearInvitationClaim();
+    setClaim(null);
+    setInvitation(null);
+    setStatus("idle");
+  }, []);
+  return { invitation, status, accept, dismiss };
+}
+function useSignIn() {
+  const client = useAuthClient();
+  return {
+    signIn: client.signIn.email,
+    signInUsername: client.signIn.username,
+    signInSocial: client.signIn.social,
+    signInSso: client.signIn.sso,
+    signInMagicLink: client.signIn.magicLink,
+    signInPasskey: client.signIn.passkey,
+    sendEmailOtp: client.emailOtp.sendVerificationOtp,
+    signInEmailOtp: client.signIn.emailOtp,
+    preparePhoneOtp: client.phoneOtp.prepare,
+    startPhoneOtp: client.phoneOtp.start,
+    verifyPhoneOtp: client.phoneOtp.verify
+  };
+}
+function usePasskeys() {
+  const client = useAuthClient();
+  return {
+    listPasskeys: client.passkey.listUserPasskeys,
+    addPasskey: client.passkey.addPasskey,
+    updatePasskey: client.passkey.updatePasskey,
+    deletePasskey: client.passkey.deletePasskey
+  };
+}
+function useMFA() {
+  const client = useAuthClient();
+  return {
+    enable: client.twoFactor.enable,
+    disable: client.twoFactor.disable,
+    verifyTotp: client.twoFactor.verifyTotp,
+    verifyBackupCode: client.twoFactor.verifyBackupCode,
+    sendOtp: client.twoFactor.sendOtp,
+    verifyOtp: client.twoFactor.verifyOtp,
+    regenerateBackupCodes: client.twoFactor.generateBackupCodes
+  };
+}
+function usePasswordReset() {
+  const client = useAuthClient();
+  return { requestPasswordReset: client.requestPasswordReset, resetPassword: client.resetPassword };
+}
+function useEmailVerification() {
+  const client = useAuthClient();
+  return {
+    sendVerificationEmail: client.sendVerificationEmail,
+    sendVerificationCode: client.emailOtp.sendVerificationOtp,
+    verifyEmailCode: client.emailOtp.verifyEmail
+  };
+}
+function useConsent() {
+  const client = useAuthClient();
+  const { user, isLoaded } = useUser();
+  const userId = user?.id ?? null;
+  const [status, setStatus] = React5.useState(null);
+  const [isLoading, setIsLoading] = React5.useState(true);
+  const reqRef = React5.useRef(0);
+  const load = React5.useCallback(async () => {
+    const reqId = ++reqRef.current;
+    setIsLoading(true);
+    let next;
+    try {
+      next = await client.getConsentStatus();
+    } catch {
+      next = { required: false };
+    }
+    if (reqId !== reqRef.current) return;
+    setStatus(next);
+    setIsLoading(false);
+  }, [client]);
+  React5.useEffect(() => {
+    reqRef.current += 1;
+    setStatus(null);
+    if (!isLoaded) {
+      setIsLoading(true);
+      return;
+    }
+    void load();
+  }, [load, isLoaded, userId]);
+  const version = typeof status?.version === "number" && Number.isFinite(status.version) ? status.version : null;
+  const accept = React5.useCallback(async () => {
+    if (version == null) return;
+    try {
+      await client.acceptConsent(version);
+    } finally {
+      await load();
+    }
+  }, [client, load, version]);
+  const needsConsent = Boolean(status?.needsConsent) && version != null;
+  return { isLoading, needsConsent, status, accept, refresh: load };
+}
+function useSignUp() {
+  const client = useAuthClient();
+  return { signUp: client.signUp.email };
+}
+function useWaitlist() {
+  return useAuthClient().waitlist;
+}
+function useSignOut() {
+  const client = useAuthClient();
+  return { signOut: client.signOut };
+}
+
+// src/components/use-submit-action.ts
+import * as React6 from "react";
+function useSubmitAction() {
+  const [pending, setPending] = React6.useState(false);
+  const [error, setError] = React6.useState(null);
+  const toMessage = useServerError();
+  const run = React6.useCallback(
+    async (action, { failure, onSuccess, mapError, keepPendingOnSuccess }) => {
+      setError(null);
+      setPending(true);
+      try {
+        const res = await action();
+        if (res?.error) {
+          setError(mapError?.(res.error) ?? toMessage(res.error, failure));
+          setPending(false);
+          return;
+        }
+        await onSuccess?.(res ?? { data: null, error: null });
+        if (!keepPendingOnSuccess) setPending(false);
+      } catch {
+        setError(failure);
+        setPending(false);
+      }
+    },
+    [toMessage]
+  );
+  return { pending, error, setError, run };
+}
+
+// src/components/Spinner.tsx
+import { Fragment as Fragment3, jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function Spinner() {
+  return /* @__PURE__ */ jsx5("span", { className: "ba-spinner", "aria-hidden": "true" });
+}
+function Busy({ busy, label, children }) {
+  return busy ? /* @__PURE__ */ jsxs4(Fragment3, { children: [
+    /* @__PURE__ */ jsx5(Spinner, {}),
+    label
+  ] }) : /* @__PURE__ */ jsx5(Fragment3, { children });
+}
+
+// src/components/FormError.tsx
+import { jsx as jsx6 } from "react/jsx-runtime";
+function FormError({ children, className, "data-testid": testId }) {
+  if (children == null || children === "" || children === false) return null;
+  return /* @__PURE__ */ jsx6(
+    "p",
+    {
+      className: className ? `ba-error ${className}` : "ba-error",
+      role: "alert",
+      "aria-live": "assertive",
+      "data-testid": testId,
+      children
+    }
+  );
+}
+
+// src/components/organization/model.ts
+function organizationSlugFromName(name) {
+  return name.normalize("NFKD").toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 63);
+}
+function organizationRoles(role) {
+  return role.split(",").map((value) => value.trim()).filter(Boolean);
+}
+function hasOrganizationRole(member, role) {
+  return member ? organizationRoles(member.role).includes(role) : false;
+}
+function canManageOrganization(member) {
+  return hasOrganizationRole(member, "owner") || hasOrganizationRole(member, "admin");
+}
+function roleHasStatement(roles, heldRoles, resource, action) {
+  return roles.some((role) => {
+    if (!heldRoles.has(role.role) || typeof role.permission !== "object" || role.permission === null) {
+      return false;
+    }
+    const actions = role.permission[resource];
+    return Array.isArray(actions) && actions.includes(action);
+  });
+}
+function teamManagementCapabilities(member, dynamicRoles) {
+  const heldRoles = new Set(organizationRoles(member.role));
+  if (heldRoles.has("owner") || heldRoles.has("admin")) {
+    return {
+      createTeam: true,
+      updateTeam: true,
+      deleteTeam: true,
+      addTeamMember: true,
+      removeTeamMember: true
+    };
+  }
+  return {
+    createTeam: roleHasStatement(dynamicRoles, heldRoles, "team", "create"),
+    updateTeam: roleHasStatement(dynamicRoles, heldRoles, "team", "update"),
+    deleteTeam: roleHasStatement(dynamicRoles, heldRoles, "team", "delete"),
+    addTeamMember: roleHasStatement(dynamicRoles, heldRoles, "member", "update"),
+    removeTeamMember: roleHasStatement(dynamicRoles, heldRoles, "member", "delete")
+  };
+}
+
+// src/components/organization/use-organization-roles.ts
+import * as React7 from "react";
+var BUILTIN_ROLES = ["owner", "admin", "member"];
+function useOrganizationRoles(organizationId) {
+  const api = useAuthClient().organization;
+  const apiRef = React7.useRef(api);
+  apiRef.current = api;
+  const [dynamicRoles, setDynamicRoles] = React7.useState([]);
+  const requestRef = React7.useRef(0);
+  React7.useEffect(() => {
+    const token = ++requestRef.current;
+    setDynamicRoles([]);
+    if (!organizationId) return;
+    void (async () => {
+      try {
+        const result = await apiRef.current.listRoles({ organizationId });
+        if (token !== requestRef.current) return;
+        setDynamicRoles((result.data ?? []).filter((entry) => entry.role.trim().length > 0));
+      } catch {
+      }
+    })();
+    return () => {
+      requestRef.current += 1;
+    };
+  }, [organizationId]);
+  const roles = React7.useMemo(() => {
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    for (const candidate of [...BUILTIN_ROLES, ...dynamicRoles.map((entry) => entry.role)]) {
+      const key = candidate.trim();
+      if (!key || seen.has(key)) continue;
+      seen.add(key);
+      out.push(key);
+    }
+    return out;
+  }, [dynamicRoles]);
+  return { roles, dynamicRoles };
+}
+
+export {
+  DEFAULT_BRAND_COLOR,
+  useAuthClient,
+  useAccount,
+  usePublicConfig,
+  useSession,
+  useUser,
+  useAuth,
+  useOrganization,
+  useOrganizationInvitation,
+  useSignIn,
+  usePasskeys,
+  useMFA,
+  usePasswordReset,
+  useEmailVerification,
+  useConsent,
+  useSignUp,
+  useWaitlist,
+  useSignOut,
+  useLocale,
+  useT,
+  richMessage,
+  Bidi,
+  useServerError,
+  ModalSurface,
+  InvitationPrompt,
+  AuthOwlProvider,
+  useAuthOwlContext,
+  useSubmitAction,
+  Spinner,
+  Busy,
+  FormError,
+  organizationSlugFromName,
+  organizationRoles,
+  hasOrganizationRole,
+  canManageOrganization,
+  teamManagementCapabilities,
+  useOrganizationRoles
+};