feat: implement tenant OAuth flow and guest achievements

resources/js/guest/context/EventStatsContext.tsx

@@ -0,0 +1,29 @@
+import React from 'react';
+import { usePollStats } from '../polling/usePollStats';
+
+type EventStatsContextValue = ReturnType<typeof usePollStats> & {
+  slug: string;
+};
+
+const EventStatsContext = React.createContext<EventStatsContextValue | undefined>(undefined);
+
+export function EventStatsProvider({ slug, children }: { slug: string; children: React.ReactNode }) {
+  const stats = usePollStats(slug);
+  const value = React.useMemo<EventStatsContextValue>(
+    () => ({ slug, ...stats }),
+    [slug, stats.onlineGuests, stats.tasksSolved, stats.latestPhotoAt, stats.loading]
+  );
+  return <EventStatsContext.Provider value={value}>{children}</EventStatsContext.Provider>;
+}
+
+export function useEventStats() {
+  const ctx = React.useContext(EventStatsContext);
+  if (!ctx) {
+    throw new Error('useEventStats must be used within an EventStatsProvider');
+  }
+  return ctx;
+}
+
+export function useOptionalEventStats() {
+  return React.useContext(EventStatsContext);
+}

resources/js/guest/context/GuestIdentityContext.tsx

@@ -0,0 +1,109 @@
+import React from 'react';
+
+type GuestIdentityContextValue = {
+  slug: string;
+  name: string;
+  hydrated: boolean;
+  setName: (nextName: string) => void;
+  clearName: () => void;
+  reload: () => void;
+};
+
+const GuestIdentityContext = React.createContext<GuestIdentityContextValue | undefined>(undefined);
+
+function storageKey(slug: string) {
+  return `guestName_${slug}`;
+}
+
+export function readGuestName(slug: string) {
+  if (!slug || typeof window === 'undefined') {
+    return '';
+  }
+
+  try {
+    return window.localStorage.getItem(storageKey(slug)) ?? '';
+  } catch (error) {
+    console.warn('Failed to read guest name', error);
+    return '';
+  }
+}
+
+export function GuestIdentityProvider({ slug, children }: { slug: string; children: React.ReactNode }) {
+  const [name, setNameState] = React.useState('');
+  const [hydrated, setHydrated] = React.useState(false);
+
+  const loadFromStorage = React.useCallback(() => {
+    if (!slug) {
+      setHydrated(true);
+      setNameState('');
+      return;
+    }
+
+    try {
+      const stored = window.localStorage.getItem(storageKey(slug));
+      setNameState(stored ?? '');
+    } catch (error) {
+      console.warn('Failed to read guest name from storage', error);
+      setNameState('');
+    } finally {
+      setHydrated(true);
+    }
+  }, [slug]);
+
+  React.useEffect(() => {
+    setHydrated(false);
+    loadFromStorage();
+  }, [loadFromStorage]);
+
+  const persistName = React.useCallback(
+    (nextName: string) => {
+      const trimmed = nextName.trim();
+      setNameState(trimmed);
+      try {
+        if (trimmed) {
+          window.localStorage.setItem(storageKey(slug), trimmed);
+        } else {
+          window.localStorage.removeItem(storageKey(slug));
+        }
+      } catch (error) {
+        console.warn('Failed to persist guest name', error);
+      }
+    },
+    [slug]
+  );
+
+  const clearName = React.useCallback(() => {
+    setNameState('');
+    try {
+      window.localStorage.removeItem(storageKey(slug));
+    } catch (error) {
+      console.warn('Failed to clear guest name', error);
+    }
+  }, [slug]);
+
+  const value = React.useMemo<GuestIdentityContextValue>(
+    () => ({
+      slug,
+      name,
+      hydrated,
+      setName: persistName,
+      clearName,
+      reload: loadFromStorage,
+    }),
+    [slug, name, hydrated, persistName, clearName, loadFromStorage]
+  );
+
+  return <GuestIdentityContext.Provider value={value}>{children}</GuestIdentityContext.Provider>;
+}
+
+export function useGuestIdentity() {
+  const ctx = React.useContext(GuestIdentityContext);
+  if (!ctx) {
+    throw new Error('useGuestIdentity must be used within a GuestIdentityProvider');
+  }
+  return ctx;
+}
+
+export function useOptionalGuestIdentity() {
+  return React.useContext(GuestIdentityContext);
+}