@authon/react-native-wallet 0.0.0-stage → 0.1.0

package/src/useAuthonWallet.ts

@@ -0,0 +1,103 @@
+import { useCallback, useContext, useEffect, useMemo, useRef, useState } from 'react';
+import { getAuthonContext } from './authonContext';
+import { AuthonWalletClient } from './client';
+import { AuthonWalletError } from './errors';
+import type { AuthonWalletOptions, EmbeddedWallet, TokenGetter } from './types';
+
+export interface UseAuthonWalletOptions extends Omit<AuthonWalletOptions, 'getToken'> {
+  /** Defaults to the session of the surrounding `<AuthonProvider>` from @authon/react-native. */
+  getToken?: TokenGetter;
+}
+
+export interface UseAuthonWalletResult {
+  /** The client; call ensure(), signMessage(), protect() etc. on it. */
+  wallet: AuthonWalletClient;
+  /** The signed-in user's wallet, null when signed out or before it is created. */
+  current: EmbeddedWallet | null;
+  /** False until the first status check finished (or while signed out and the auth SDK is loading). */
+  isLoaded: boolean;
+  error: AuthonWalletError | null;
+  /** Reloads `current`. */
+  refresh: () => Promise<void>;
+}
+
+/**
+ * Wallet of the signed-in user. Inside `<AuthonProvider>` (@authon/react-native) the session token
+ * comes from the provider and the wallet follows sign-in and sign-out; elsewhere pass `getToken`.
+ * The client is recreated only when publishableKey, apiUrl or appId change.
+ */
+export function useAuthonWallet(options: UseAuthonWalletOptions): UseAuthonWalletResult {
+  const session = useContext(getAuthonContext());
+  const latest = useRef({ options, session });
+  latest.current = { options, session };
+
+  if (!options.getToken && !session) {
+    throw new AuthonWalletError(
+      'NOT_CONFIGURED',
+      'useAuthonWallet needs getToken, or must be used inside <AuthonProvider> from @authon/react-native',
+    );
+  }
+
+  const appIdKey = typeof options.appId === 'string' ? options.appId : JSON.stringify(options.appId ?? null);
+  const testingKey = JSON.stringify(options.testing ?? null);
+  const wallet = useMemo(
+    () =>
+      new AuthonWalletClient({
+        ...latest.current.options,
+        getToken: async () => {
+          const { options: o, session: s } = latest.current;
+          if (o.getToken) return o.getToken();
+          if (!s?.isSignedIn) return null;
+          const token = s.getToken?.();
+          if (token) return token;
+          return (await s.client?.refreshToken?.())?.accessToken ?? null;
+        },
+      }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [options.publishableKey, options.apiUrl, appIdKey, options.requireDeviceAuthentication, testingKey],
+  );
+  // dispose() only resets the client, so this is safe under StrictMode's double effects.
+  useEffect(() => () => wallet.dispose(), [wallet]);
+
+  const [current, setCurrent] = useState<EmbeddedWallet | null>(null);
+  const [isLoaded, setLoaded] = useState(false);
+  const [error, setError] = useState<AuthonWalletError | null>(null);
+
+  useEffect(() => wallet.onChange(setCurrent), [wallet]);
+
+  const signedIn = options.getToken ? true : session?.isSignedIn === true;
+  const sessionUser = options.getToken ? null : session?.userId ?? null;
+  const authLoaded = options.getToken ? true : session?.isLoaded !== false;
+
+  const lastUser = useRef<string | null | undefined>(undefined);
+
+  const refresh = useCallback(async () => {
+    try {
+      setCurrent(await wallet.get());
+      setError(null);
+    } catch (e) {
+      setError(e instanceof AuthonWalletError ? e : new AuthonWalletError('UNKNOWN', String(e)));
+    } finally {
+      setLoaded(true);
+    }
+  }, [wallet]);
+
+  useEffect(() => {
+    if (!authLoaded) return;
+    if (!signedIn) {
+      wallet.dispose();
+      lastUser.current = undefined;
+      setCurrent(null);
+      setError(null);
+      setLoaded(true);
+      return;
+    }
+    // Another user signed in: drop the previous user's cached accounts and in-flight calls.
+    if (lastUser.current !== undefined && lastUser.current !== sessionUser) wallet.dispose();
+    lastUser.current = sessionUser;
+    setLoaded(false);
+    void refresh();
+  }, [authLoaded, signedIn, sessionUser, refresh, wallet]);
+
+  return { wallet, current, isLoaded, error, refresh };
+}