@powerhousedao/reactor-browser 6.2.2-dev.2 → 6.2.2-dev.20

package/dist/{renown-D-1c_Bvx.js → renown-DBvu1oq7.js}

@@ -1,8 +1,21 @@
 import { t as makePHEventFunctions } from "./make-ph-event-functions-BHoLPif5.js";
 import { logger } from "document-model";
-import { Children, cloneElement, forwardRef, isValidElement, useCallback, useEffect, useRef, useState, useSyncExternalStore } from "react";
-import { BrowserKeyStorage, CREDENTIAL_SCHEMA_EIP712_TYPE, CREDENTIAL_SUBJECT_TYPE, CREDENTIAL_TYPES, DOMAIN_TYPE, ISSUER_TYPE, RenownBuilder, RenownCryptoBuilder, VERIFIABLE_CREDENTIAL_EIP712_TYPE } from "@renown/sdk";
+import { Children, cloneElement, createContext, forwardRef, isValidElement, useCallback, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { BrowserKeyStorage, CREDENTIAL_SCHEMA_EIP712_TYPE, CREDENTIAL_SUBJECT_TYPE, CREDENTIAL_TYPES, DOMAIN_TYPE, ISSUER_TYPE, RenownBuilder, RenownCryptoBuilder, VERIFIABLE_CREDENTIAL_EIP712_TYPE, readPersistedUser } from "@renown/sdk";
+import { DEFAULT_MOCK_METHODS, DEFAULT_PRIVY_METHODS, LoginMethod, isWalletRedirectReturn, resolveAdapters } from "@renown/sdk/wallet";
+//#region src/renown/initial-user.tsx
+const RenownInitialUserContext = createContext(void 0);
+function RenownInitialUserProvider({ initialUser, children }) {
+	return /* @__PURE__ */ jsx(RenownInitialUserContext.Provider, {
+		value: initialUser,
+		children
+	});
+}
+function useRenownInitialUser() {
+	return useContext(RenownInitialUserContext);
+}
+//#endregion
 //#region src/hooks/loading.ts
 const { useValue: useLoading, setValue: setLoading, addEventHandler: addLoadingEventHandler } = makePHEventFunctions("loading");
 const loading = null;
@@ -22,12 +35,15 @@ function useDid() {
 /** Returns the current user from the renown instance, subscribing to user events */
 function useUser() {
 	const renown = useRenown();
-	const [user, setUser] = useState(renown?.user);
+	const initialUser = useRenownInitialUser();
+	const instance = renown ? renown : void 0;
+	const [user, setUser] = useState(instance ? instance.user : initialUser);
 	useEffect(() => {
-		setUser(renown?.user);
-		if (!renown) return;
-		return renown.on("user", setUser);
-	}, [renown]);
+		if (instance) {
+			setUser(instance.user);
+			return instance.on("user", setUser);
+		}
+	}, [instance]);
 	return user;
 }
 /** Returns the login status, subscribing to renown status events */
@@ -39,12 +55,46 @@ function useLoginStatus() {
 	}, () => renown === null ? "loading" : renown?.status, () => void 0);
 }
 //#endregion
+//#region src/renown/wallet-registry.ts
+let activeWalletController;
+let controllerWaiters = [];
+let walletActivator;
+function setActiveWalletController(controller) {
+	activeWalletController = controller;
+	if (controller) {
+		const waiters = controllerWaiters;
+		controllerWaiters = [];
+		waiters.forEach(({ resolve }) => resolve(controller));
+	}
+}
+function failWalletActivation(error) {
+	const waiters = controllerWaiters;
+	controllerWaiters = [];
+	waiters.forEach(({ reject }) => reject(error));
+}
+function getActiveWalletController() {
+	return activeWalletController;
+}
+function setWalletActivator(activator) {
+	walletActivator = activator;
+}
+function getWalletActivator() {
+	return walletActivator;
+}
+function whenWalletControllerReady() {
+	if (activeWalletController) return Promise.resolve(activeWalletController);
+	return new Promise((resolve, reject) => controllerWaiters.push({
+		resolve,
+		reject
+	}));
+}
+//#endregion
 //#region src/renown/constants.ts
 const RENOWN_URL = "https://www.renown.id";
 const RENOWN_NETWORK_ID = "eip155";
 const RENOWN_CHAIN_ID = "1";
 //#endregion
-//#region src/renown/utils.ts
+//#region src/renown/session.ts
 function openRenown(documentId) {
 	const renown = window.ph?.renown;
 	let renownUrl = renown?.baseUrl;
@@ -65,10 +115,43 @@ function openRenown(documentId) {
 	url.searchParams.set("returnUrl", returnUrl.toJSON());
 	window.open(url, "_self")?.focus();
 }
-/**
-* Reads the `?user=` DID from the URL if present.
-* Returns the DID and cleans up the URL parameter.
-*/
+async function signIn(session) {
+	const renown = window.ph?.renown;
+	if (!renown) {
+		logger.warn("Renown instance not found, cannot sign in");
+		return;
+	}
+	return renown.signIn({
+		address: session.address,
+		chainId: session.chainId,
+		signTypedData: session.signTypedData
+	});
+}
+let inFlightSignIn;
+let inFlightAddress;
+let lastSignedAddress;
+async function completeSignIn(session) {
+	const { address } = session;
+	if (address === lastSignedAddress) return;
+	if (inFlightSignIn && address === inFlightAddress) return inFlightSignIn;
+	inFlightAddress = address;
+	inFlightSignIn = (async () => {
+		try {
+			const user = await signIn(session);
+			if (user) lastSignedAddress = address;
+			return user;
+		} finally {
+			inFlightSignIn = void 0;
+			inFlightAddress = void 0;
+		}
+	})();
+	return inFlightSignIn;
+}
+function resetSignInGuard() {
+	inFlightSignIn = void 0;
+	inFlightAddress = void 0;
+	lastSignedAddress = void 0;
+}
 function consumeDidFromUrl() {
 	if (typeof window === "undefined") return;
 	const userParam = new URLSearchParams(window.location.search).get("user");
@@ -79,12 +162,6 @@ function consumeDidFromUrl() {
 	window.history.replaceState({}, "", cleanUrl.toString());
 	return userDid;
 }
-/**
-* Log in the user. Resolves the user DID from (in order):
-* 1. Explicit `userDid` argument
-* 2. `?user=` URL parameter (from Renown portal redirect)
-* 3. Previously stored session in the Renown instance
-*/
 async function login(userDid, renown) {
 	if (!renown) return;
 	const did = userDid ?? consumeDidFromUrl();
@@ -98,7 +175,13 @@ async function login(userDid, renown) {
 	}
 }
 async function logout() {
+	try {
+		await getActiveWalletController()?.disconnect();
+	} catch (error) {
+		logger.error(error instanceof Error ? error.message : String(error));
+	}
 	await (window.ph?.renown)?.logout();
+	resetSignInGuard();
 	const url = new URL(window.location.href);
 	if (url.searchParams.has("user")) {
 		url.searchParams.delete("user");
@@ -111,13 +194,20 @@ function truncateAddress$1(address) {
 	if (address.length <= 13) return address;
 	return `${address.slice(0, 7)}...${address.slice(-5)}`;
 }
+function isUserCancellation(error) {
+	const msg = error.message.toLowerCase();
+	return msg.includes("exited_auth_flow") || msg.includes("user rejected") || msg.includes("user denied") || msg.includes("userrejected") || msg.includes("cancel");
+}
 function toRenownAuthStatus(loginStatus, user) {
 	if (loginStatus === "authorized") return user ? "authorized" : "checking";
 	return loginStatus;
 }
 function useRenownAuth() {
 	const user = useUser();
-	const status = toRenownAuthStatus(useLoginStatus(), user);
+	const loginStatus = useLoginStatus();
+	const [pending, setPending] = useState(false);
+	const [error, setError] = useState(void 0);
+	const status = toRenownAuthStatus(loginStatus, user);
 	const address = user?.address;
 	const ensName = user?.ens?.name;
 	const avatarUrl = user?.profile?.userImage ?? user?.ens?.avatarUrl;
@@ -131,9 +221,39 @@ function useRenownAuth() {
 		profileId,
 		displayName: ensName ?? user?.profile?.username ?? void 0,
 		displayAddress: address ? truncateAddress$1(address) : void 0,
-		login: useCallback(() => {
-			openRenown();
+		login: useCallback((session, method) => {
+			const existing = getActiveWalletController();
+			const activator = getWalletActivator();
+			if (!session && !existing && !activator) {
+				openRenown();
+				return;
+			}
+			setPending(true);
+			setError(void 0);
+			(async () => {
+				try {
+					let resolved = session;
+					if (!resolved) {
+						const activated = existing ?? (activator ? await activator() : void 0);
+						resolved = await (getActiveWalletController() ?? activated)?.connect(method);
+					}
+					if (!resolved) {
+						openRenown();
+						return;
+					}
+					await completeSignIn(resolved);
+				} catch (e) {
+					const err = e instanceof Error ? e : new Error(String(e));
+					if (isUserCancellation(err)) return;
+					setError(err);
+					if (/switchboard/i.test(err.message)) openRenown();
+				} finally {
+					setPending(false);
+				}
+			})();
 		}, []),
+		pending,
+		error,
 		logout: useCallback(async () => {
 			await logout();
 		}, []),
@@ -142,6 +262,19 @@ function useRenownAuth() {
 		}, [profileId])
 	};
 }
+function useRenownAuthAsync() {
+	const auth = useRenownAuth();
+	const { user, status, pending } = auth;
+	let state;
+	if (user) state = "authenticated";
+	else if (pending || status === void 0 || status === "loading" || status === "checking") state = "resolving";
+	else state = "unauthenticated";
+	return {
+		...auth,
+		state,
+		isResolving: state === "resolving"
+	};
+}
 //#endregion
 //#region src/renown/components/icons.tsx
 function RenownLogo({ width = 71, height = 19, hovered = false, color = "currentColor", className }) {
@@ -849,13 +982,80 @@ async function initRenownCrypto() {
 	return await new RenownCryptoBuilder().withKeyPairStorage(keyStorage).build();
 }
 //#endregion
+//#region src/renown/use-renown-session-cookie.ts
+const DEFAULT_ENDPOINT = "/api/renown/session";
+const DEFAULT_EXPIRES_IN = 10080 * 60;
+function useRenownSessionCookie(options = {}) {
+	const endpoint = options.endpoint ?? DEFAULT_ENDPOINT;
+	const expiresIn = options.expiresIn ?? DEFAULT_EXPIRES_IN;
+	const enabled = options.enabled ?? true;
+	const { user, displayName, avatarUrl } = useRenownAuth();
+	const renown = useRenown();
+	const address = user?.address;
+	const hadUser = useRef(false);
+	const [synced, setSynced] = useState(false);
+	useEffect(() => {
+		if (!enabled) return;
+		const ready = !!renown && typeof renown.getBearerToken === "function";
+		if (address && ready) {
+			hadUser.current = true;
+			setSynced(false);
+			let cancelled = false;
+			(async () => {
+				try {
+					const token = await renown.getBearerToken({ expiresIn });
+					await fetch(endpoint, {
+						method: "POST",
+						headers: { "content-type": "application/json" },
+						body: JSON.stringify({
+							token,
+							profile: {
+								name: displayName ?? null,
+								avatar: avatarUrl ?? null
+							}
+						})
+					});
+					if (!cancelled) setSynced(true);
+				} catch (error) {
+					console.error("Failed to sync Renown session cookie", error);
+				}
+			})();
+			return () => {
+				cancelled = true;
+			};
+		}
+		if (!address) {
+			setSynced(false);
+			if (hadUser.current) {
+				hadUser.current = false;
+				fetch(endpoint, { method: "DELETE" }).catch(() => {});
+			}
+		}
+	}, [
+		address,
+		displayName,
+		avatarUrl,
+		renown,
+		endpoint,
+		expiresIn,
+		enabled
+	]);
+	return { synced };
+}
+const RenownSessionSyncedContext = createContext(false);
+function useRenownSessionSynced() {
+	return useContext(RenownSessionSyncedContext);
+}
+//#endregion
 //#region src/renown/use-renown-init.ts
-async function initRenown(appName, namespace, url) {
+async function initRenown(appName, namespace, url, switchboardUrl, revalidate) {
 	addRenownEventHandler();
 	setRenown(null);
 	const renown = await new RenownBuilder(appName, {
 		basename: namespace,
-		baseUrl: url
+		baseUrl: url,
+		switchboardUrl,
+		revalidate
 	}).build();
 	setRenown(renown);
 	await login(void 0, renown);
@@ -874,14 +1074,14 @@ async function initRenown(appName, namespace, url) {
 * }
 * ```
 */
-function useRenownInit({ appName, namespace, url }) {
+function useRenownInit({ appName, namespace, url, switchboardUrl, revalidate = "always" }) {
 	const promiseRef = useRef(null);
 	promiseRef.current ??= Promise.withResolvers();
 	const initRef = useRef(false);
 	useEffect(() => {
 		if (initRef.current) return;
 		initRef.current = true;
-		initRenown(appName, namespace, url).then(promiseRef.current.resolve).catch(promiseRef.current.reject);
+		initRenown(appName, namespace, url, switchboardUrl, revalidate).then(promiseRef.current.resolve).catch(promiseRef.current.reject);
 	}, []);
 	return promiseRef.current.promise;
 }
@@ -908,6 +1108,203 @@ function Renown({ onError, ...initOptions }) {
 	return null;
 }
 //#endregion
-export { useLoginStatus as A, RENOWN_CHAIN_ID as C, addRenownEventHandler as D, VERIFIABLE_CREDENTIAL_EIP712_TYPE as E, setLoading as F, useLoading as I, useUser as M, addLoadingEventHandler as N, setRenown as O, loading as P, ISSUER_TYPE as S, RENOWN_URL as T, openRenown as _, RenownAuthButton as a, CREDENTIAL_TYPES as b, ChevronDownIcon as c, RenownLogo as d, SpinnerIcon as f, logout as g, login as h, initRenownCrypto as i, useRenown as j, useDid as k, CopyIcon as l, useRenownAuth as m, useRenownInit as n, RenownUserButton as o, UserIcon as p, initConnectCrypto as r, RenownLoginButton as s, Renown as t, DisconnectIcon as u, CREDENTIAL_SCHEMA_EIP712_TYPE as v, RENOWN_NETWORK_ID as w, DOMAIN_TYPE as x, CREDENTIAL_SUBJECT_TYPE as y };
+//#region src/renown/use-complete-redirect-sign-in.ts
+function useCompleteRedirectSignIn() {
+	const renown = useRenown();
+	const user = useUser();
+	const [pendingSilentSession, setPendingSilentSession] = useState(null);
+	const oauthReturnRef = useRef(typeof window !== "undefined" && isWalletRedirectReturn(window.location.search));
+	const onSession = useCallback((_id, session) => {
+		setPendingSilentSession(session?.canSignSilently ? session : null);
+	}, []);
+	useEffect(() => {
+		if (!oauthReturnRef.current) return;
+		if (user) {
+			oauthReturnRef.current = false;
+			return;
+		}
+		if (!pendingSilentSession || !renown) return;
+		oauthReturnRef.current = false;
+		Promise.resolve(completeSignIn(pendingSilentSession)).catch((error) => logger.error(error instanceof Error ? error.message : String(error)));
+	}, [
+		pendingSilentSession,
+		renown,
+		user
+	]);
+	return { onSession };
+}
+//#endregion
+//#region src/renown/wallet-provider.tsx
+function mergeControllers(controllers) {
+	if (controllers.length === 0) return void 0;
+	return {
+		supportedMethods: Array.from(new Set(controllers.flatMap((c) => c.supportedMethods))),
+		connect(method) {
+			if (method) {
+				const target = controllers.find((c) => c.supportedMethods.includes(method));
+				if (!target) throw new Error(`No wallet adapter supports login method "${method}"`);
+				return target.connect(method);
+			}
+			const chosen = controllers.at(0);
+			if (!chosen) throw new Error("No wallet adapter available");
+			return chosen.connect(method);
+		},
+		async disconnect() {
+			await Promise.all(controllers.map((c) => c.disconnect()));
+		},
+		getSession() {
+			for (const c of controllers) {
+				const session = c.getSession();
+				if (session) return session;
+			}
+		}
+	};
+}
+function AdapterControllerBridge(props) {
+	const { adapter, onController, onSession } = props;
+	const controller = adapter.useController();
+	useEffect(() => {
+		onController(adapter.id, controller);
+		return () => onController(adapter.id, void 0);
+	}, [
+		adapter.id,
+		controller,
+		onController
+	]);
+	useEffect(() => {
+		if (!controller.subscribe) return;
+		return controller.subscribe((session) => onSession(adapter.id, session));
+	}, [
+		adapter.id,
+		controller,
+		onSession
+	]);
+	return null;
+}
+/** Drop-in provider for Renown in-page wallet sign-in: registers the login activator, lazy-mounts the configured adapters on first click, and merges their controllers for {@link useRenownAuth}. Full walkthrough + examples: the `@powerhousedao/reactor-browser` README ("Renown in-page sign-in") and the Academy Renown authentication guide. Pair with {@link useRenownLoginMethods} to build the login UI. */
+function RenownWalletProvider({ adapters: adaptersConfig, theme, children }) {
+	const [config] = useState(() => adaptersConfig);
+	const user = useUser();
+	const [activated, setActivated] = useState(() => typeof window !== "undefined" && isWalletRedirectReturn(window.location.search));
+	if (user && !activated) setActivated(true);
+	const active = activated;
+	const [adapters, setAdapters] = useState(null);
+	const controllersRef = useRef(/* @__PURE__ */ new Map());
+	const { onSession } = useCompleteRedirectSignIn();
+	useEffect(() => {
+		if (!config) return;
+		setWalletActivator(() => {
+			setActivated(true);
+			return whenWalletControllerReady();
+		});
+		return () => setWalletActivator(void 0);
+	}, [config]);
+	useEffect(() => {
+		if (!active || !config) return;
+		let cancelled = false;
+		resolveAdapters(config).then((resolved) => {
+			if (cancelled) return;
+			if (resolved.length === 0) {
+				failWalletActivation(/* @__PURE__ */ new Error("No wallet adapters could be loaded. Check that the configured adapters' peer dependencies are installed."));
+				return;
+			}
+			setAdapters(resolved);
+		}).catch((error) => {
+			if (!cancelled) failWalletActivation(error instanceof Error ? error : new Error(String(error)));
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, [active, config]);
+	const onController = useCallback((id, controller) => {
+		if (controller) controllersRef.current.set(id, controller);
+		else controllersRef.current.delete(id);
+		setActiveWalletController(mergeControllers(Array.from(controllersRef.current.values())));
+	}, []);
+	return /* @__PURE__ */ jsxs(Fragment, { children: [children, config && active && adapters && adapters.length > 0 ? adapters.reduceRight((acc, adapter) => {
+		const Provider = adapter.Provider;
+		return /* @__PURE__ */ jsx(Provider, {
+			theme,
+			children: acc
+		});
+	}, /* @__PURE__ */ jsx(Fragment, { children: adapters.map((adapter) => /* @__PURE__ */ jsx(AdapterControllerBridge, {
+		adapter,
+		onController,
+		onSession
+	}, adapter.id)) })) : null] });
+}
+//#endregion
+//#region src/renown/provider.tsx
+function SessionSync({ enabled, endpoint, children }) {
+	const { synced } = useRenownSessionCookie({
+		endpoint,
+		enabled
+	});
+	return /* @__PURE__ */ jsx(RenownSessionSyncedContext.Provider, {
+		value: synced,
+		children
+	});
+}
+function RenownProvider({ appName, namespace, url, switchboardUrl, adapters, theme, revalidate, session, sessionEndpoint, onError, children }) {
+	const isServerSession = session !== void 0;
+	const seed = useMemo(() => {
+		if (isServerSession) return session?.user ?? void 0;
+		return readPersistedUser(namespace);
+	}, [
+		isServerSession,
+		session,
+		namespace
+	]);
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(Renown, {
+		appName,
+		namespace,
+		url,
+		switchboardUrl,
+		revalidate,
+		onError
+	}), /* @__PURE__ */ jsx(RenownInitialUserProvider, {
+		initialUser: seed,
+		children: /* @__PURE__ */ jsx(RenownWalletProvider, {
+			adapters,
+			theme,
+			children: /* @__PURE__ */ jsx(SessionSync, {
+				enabled: isServerSession,
+				endpoint: sessionEndpoint,
+				children
+			})
+		})
+	})] });
+}
+//#endregion
+//#region src/renown/login-methods.ts
+const DEFAULT_METHOD_LABELS = {
+	[LoginMethod.WALLET]: "Connect a Wallet",
+	[LoginMethod.GOOGLE]: "Continue with Google",
+	[LoginMethod.EMAIL]: "Continue with Email",
+	[LoginMethod.APPLE]: "Continue with Apple"
+};
+/** Derive the offered login methods (wallet + Privy's methods) from an adapters config, for building a login UI. Reads config only — no wallet libraries load. Wire each to `useRenownAuth().login(undefined, id)`. Labels are overridable. See the reactor-browser README + Academy Renown auth guide. */
+function useRenownLoginMethods(adapters, labels) {
+	return useMemo(() => {
+		if (!adapters) return [];
+		const label = (id) => labels?.[id] ?? DEFAULT_METHOD_LABELS[id] ?? id;
+		const seen = /* @__PURE__ */ new Set();
+		const methods = [];
+		const add = (id) => {
+			if (seen.has(id)) return;
+			seen.add(id);
+			methods.push({
+				id,
+				label: label(id)
+			});
+		};
+		if (adapters.rainbow) add(LoginMethod.WALLET);
+		if (adapters.privy) (adapters.privy.methods?.length ? adapters.privy.methods : DEFAULT_PRIVY_METHODS).forEach(add);
+		if (adapters.mock) (adapters.mock.methods?.length ? adapters.mock.methods : DEFAULT_MOCK_METHODS).forEach(add);
+		return methods;
+	}, [adapters, labels]);
+}
+//#endregion
+export { RENOWN_NETWORK_ID as A, loading as B, openRenown as C, DOMAIN_TYPE as D, CREDENTIAL_TYPES as E, useDid as F, useLoading as H, useLoginStatus as I, useRenown as L, VERIFIABLE_CREDENTIAL_EIP712_TYPE as M, addRenownEventHandler as N, ISSUER_TYPE as O, setRenown as P, useUser as R, logout as S, CREDENTIAL_SUBJECT_TYPE as T, RenownInitialUserProvider as U, setLoading as V, useRenownInitialUser as W, SpinnerIcon as _, useRenownInit as a, useRenownAuthAsync as b, initConnectCrypto as c, RenownUserButton as d, RenownLoginButton as f, RenownLogo as g, DisconnectIcon as h, Renown as i, RENOWN_URL as j, RENOWN_CHAIN_ID as k, initRenownCrypto as l, CopyIcon as m, RenownProvider as n, useRenownSessionCookie as o, ChevronDownIcon as p, RenownWalletProvider as r, useRenownSessionSynced as s, useRenownLoginMethods as t, RenownAuthButton as u, UserIcon as v, CREDENTIAL_SCHEMA_EIP712_TYPE as w, login as x, useRenownAuth as y, addLoadingEventHandler as z };
 
-//# sourceMappingURL=renown-D-1c_Bvx.js.map
+//# sourceMappingURL=renown-DBvu1oq7.js.map