@proveanything/smartlinks-auth-ui 0.3.0 → 0.3.3

package/dist/index.esm.js

@@ -11427,6 +11427,7 @@ const tokenStorage = {
     },
 };
 
+// Export context for optional usage (e.g., SmartlinksFrame can work without AuthProvider)
 const AuthContext = createContext(undefined);
 const AuthProvider = ({ children, proxyMode = false, accountCacheTTL = 5 * 60 * 1000, preloadAccountInfo = false, 
 // Token refresh settings
@@ -14310,6 +14311,673 @@ const AccountManagement = ({ apiEndpoint, clientId, collectionId, onError, class
                                         }, className: "auth-button button-secondary", children: "Cancel" })] })] }))] }))] }));
 };
 
+/**
+ * Helper functions for SmartlinksFrame
+ * Separated to avoid circular dependencies
+ */
+/**
+ * Compute admin status from collection/proof roles.
+ */
+function isAdminFromRoles(user, collection, proof) {
+    if (!user?.uid)
+        return false;
+    const proofRole = proof?.roles?.[user.uid];
+    if (proofRole === 'admin' || proofRole === 'owner')
+        return true;
+    const collectionRole = collection?.roles?.[user.uid];
+    if (collectionRole === 'admin' || collectionRole === 'owner')
+        return true;
+    return false;
+}
+/**
+ * Build iframe src URL with query parameters.
+ */
+function buildIframeSrc(baseUrl, params) {
+    const url = new URL(baseUrl);
+    Object.entries(params).forEach(([key, value]) => {
+        if (value !== undefined) {
+            url.searchParams.set(key, value);
+        }
+    });
+    return url.toString();
+}
+
+/**
+ * SmartlinksFrame - React wrapper for embedding SmartLinks microapps.
+ *
+ * This component handles iframe creation and message passing for SmartLinks apps.
+ * It requires only collectionId and appId - the SDK handles URL discovery and API proxying.
+ *
+ * @example
+ * ```tsx
+ * // Simple usage - SDK resolves app URL automatically
+ * <SmartlinksFrame
+ *   collectionId="my-collection"
+ *   appId="warranty-app"
+ * />
+ *
+ * // With optional product context
+ * <SmartlinksFrame
+ *   collectionId="my-collection"
+ *   appId="warranty-app"
+ *   productId="product-123"
+ * />
+ * ```
+ */
+const SmartlinksFrame = ({ collectionId, appId, productId, proofId, version = 'stable', collection, product: _product, // Destructured but currently unused - kept for cache optimization
+proof, initialPath, onRouteChange, autoResize = true, minHeight, maxHeight, onReady, onError, className, style, }) => {
+    const iframeRef = useRef(null);
+    const [src, setSrc] = useState(null);
+    const [height, setHeight] = useState(minHeight || 400);
+    const [error, setError] = useState(null);
+    const [isLoading, setIsLoading] = useState(true);
+    // Get auth context if available (optional - works without AuthProvider)
+    const authContext = useContext(AuthContext);
+    const user = authContext?.user ?? null;
+    // Compute isAdmin from collection/proof roles
+    const isAdmin = isAdminFromRoles(user ? { uid: user.uid } : null, collection, proof);
+    // Handle messages from iframe
+    const handleMessage = useCallback((event) => {
+        const data = event.data;
+        if (!data || typeof data !== 'object')
+            return;
+        // Handle resize messages
+        if (data.type === 'smartlinks:resize' && autoResize) {
+            let newHeight = data.payload?.height || data.height;
+            if (typeof newHeight === 'number') {
+                if (minHeight)
+                    newHeight = Math.max(newHeight, minHeight);
+                if (maxHeight)
+                    newHeight = Math.min(newHeight, maxHeight);
+                setHeight(newHeight);
+            }
+        }
+        // Handle route change messages
+        if (data.type === 'smartlinks-route-change' && onRouteChange) {
+            onRouteChange(data.path || '/', data.state || {});
+        }
+        // Handle ready message
+        if (data.type === 'smartlinks:ready') {
+            setIsLoading(false);
+            onReady?.();
+        }
+    }, [autoResize, minHeight, maxHeight, onRouteChange, onReady]);
+    // Set up message listener
+    useEffect(() => {
+        window.addEventListener('message', handleMessage);
+        return () => window.removeEventListener('message', handleMessage);
+    }, [handleMessage]);
+    // Resolve app URL and set iframe src
+    useEffect(() => {
+        setError(null);
+        setIsLoading(true);
+        setSrc(null);
+        // Try to get app URL from collection apps config
+        const resolveAppUrl = async () => {
+            try {
+                // Use SDK to get collection data which may include apps config
+                const collectionData = await smartlinks.collection.get(collectionId);
+                const collectionAsAny = collectionData;
+                const apps = collectionAsAny.apps ?? [];
+                const app = apps.find((a) => a.id === appId);
+                if (!app?.url) {
+                    throw new Error(`App "${appId}" not found in collection "${collectionId}"`);
+                }
+                // Get the appropriate URL based on version
+                let baseUrl = app.url;
+                if (version === 'development' && app.versions?.development) {
+                    baseUrl = app.versions.development;
+                }
+                else if (version === 'stable' && app.versions?.stable) {
+                    baseUrl = app.versions.stable;
+                }
+                // Build iframe URL with context params
+                const iframeSrc = buildIframeSrc(baseUrl, {
+                    collectionId,
+                    appId,
+                    productId,
+                    proofId,
+                    isAdmin: isAdmin ? '1' : '0',
+                    dark: document.documentElement.classList.contains('dark') ? '1' : '0',
+                });
+                // Add initial path if provided
+                const finalSrc = initialPath
+                    ? `${iframeSrc}#${initialPath}`
+                    : iframeSrc;
+                setSrc(finalSrc);
+                setIsLoading(false);
+            }
+            catch (err) {
+                const errorMsg = err instanceof Error ? err.message : 'Failed to resolve app URL';
+                console.error('[SmartlinksFrame] Error:', errorMsg);
+                setError(errorMsg);
+                setIsLoading(false);
+                onError?.(err instanceof Error ? err : new Error(errorMsg));
+            }
+        };
+        resolveAppUrl();
+    }, [collectionId, appId, productId, proofId, version, initialPath, isAdmin, onError]);
+    // Calculate container style
+    const containerStyle = {
+        position: 'relative',
+        height: autoResize ? `${height}px` : '100%',
+        width: '100%',
+        ...style,
+    };
+    return (jsxs("div", { className: className, style: containerStyle, children: [error && (jsxs("div", { style: {
+                    padding: '0.5rem 1rem',
+                    backgroundColor: '#fee2e2',
+                    color: '#dc2626',
+                    borderBottom: '1px solid #fecaca',
+                    fontSize: '0.875rem',
+                }, children: ["Error: ", error] })), isLoading && !error && (jsx("div", { style: {
+                    display: 'flex',
+                    alignItems: 'center',
+                    justifyContent: 'center',
+                    height: '100%',
+                    minHeight: minHeight || 200,
+                    color: '#6b7280',
+                }, children: "Loading..." })), src && (jsx("iframe", { ref: iframeRef, src: src, frameBorder: 0, width: "100%", height: "100%", allow: "camera;microphone;fullscreen;geolocation;identity-credentials-get", style: {
+                    display: isLoading ? 'none' : 'block',
+                    width: '100%',
+                    height: autoResize ? `${height}px` : '100%',
+                    border: 'none',
+                } }))] }));
+};
+
+/**
+ * Hook to detect if the current user is an admin of the collection or proof.
+ *
+ * Admin status is determined by checking if the user's UID exists in the
+ * `roles` object of either the collection or proof.
+ *
+ * @param collection - Collection object with optional roles
+ * @param proof - Proof object with optional roles
+ * @param user - Current authenticated user
+ * @returns boolean indicating admin status
+ */
+function useAdminDetection(collection, proof, user) {
+    return useMemo(() => {
+        if (!user?.uid)
+            return false;
+        // Check collection roles
+        if (collection?.roles && collection.roles[user.uid]) {
+            return true;
+        }
+        // Check proof roles (for proof-level admin)
+        if (proof?.roles && proof.roles[user.uid]) {
+            return true;
+        }
+        return false;
+    }, [collection?.roles, proof?.roles, user?.uid]);
+}
+
+/**
+ * Hook to handle iframe height management.
+ *
+ * Supports two modes:
+ * 1. Viewport-based: Calculates height based on iframe position and viewport
+ * 2. Content-based: Listens for smartlinks:resize messages from the iframe
+ *
+ * @param iframeRef - Ref to the iframe element
+ * @param options - Resize configuration options
+ * @returns Current calculated height in pixels
+ */
+function useIframeResize(iframeRef, options = {}) {
+    const { autoResize = true, minHeight, maxHeight } = options;
+    const [height, setHeight] = useState(0);
+    // Calculate height based on viewport position
+    const calculateHeight = useCallback(() => {
+        const iframe = iframeRef.current;
+        if (!iframe)
+            return;
+        const container = iframe.parentElement;
+        if (!container)
+            return;
+        const rect = container.getBoundingClientRect();
+        const viewportHeight = window.innerHeight;
+        let calculatedHeight = Math.max(0, viewportHeight - rect.top);
+        // Apply constraints
+        if (minHeight !== undefined) {
+            calculatedHeight = Math.max(calculatedHeight, minHeight);
+        }
+        if (maxHeight !== undefined) {
+            calculatedHeight = Math.min(calculatedHeight, maxHeight);
+        }
+        setHeight(calculatedHeight);
+    }, [minHeight, maxHeight, iframeRef]);
+    // Handle viewport resize events
+    useEffect(() => {
+        if (!autoResize)
+            return;
+        // Initial calculation with multiple retries for late layout
+        calculateHeight();
+        const t1 = setTimeout(calculateHeight, 10);
+        const t2 = setTimeout(calculateHeight, 100);
+        const t3 = setTimeout(calculateHeight, 500);
+        const handleResize = () => calculateHeight();
+        window.addEventListener('resize', handleResize);
+        window.addEventListener('orientationchange', handleResize);
+        return () => {
+            clearTimeout(t1);
+            clearTimeout(t2);
+            clearTimeout(t3);
+            window.removeEventListener('resize', handleResize);
+            window.removeEventListener('orientationchange', handleResize);
+        };
+    }, [autoResize, calculateHeight]);
+    // Listen for content-based resize messages from iframe
+    useEffect(() => {
+        const handleMessage = (event) => {
+            // Validate source is our iframe
+            if (iframeRef.current && event.source !== iframeRef.current.contentWindow) {
+                return;
+            }
+            const data = event.data;
+            // Handle smartlinks:resize message
+            if (data?._smartlinksIframeMessage && data?.type === 'smartlinks:resize') {
+                const contentHeight = data.payload?.height;
+                if (typeof contentHeight === 'number' && contentHeight > 0) {
+                    let newHeight = contentHeight;
+                    // Apply constraints
+                    if (minHeight !== undefined) {
+                        newHeight = Math.max(newHeight, minHeight);
+                    }
+                    if (maxHeight !== undefined) {
+                        newHeight = Math.min(newHeight, maxHeight);
+                    }
+                    setHeight(newHeight);
+                }
+            }
+        };
+        window.addEventListener('message', handleMessage);
+        return () => window.removeEventListener('message', handleMessage);
+    }, [iframeRef, minHeight, maxHeight]);
+    return height;
+}
+
+// Re-import the constant since we can't import from types
+const KNOWN_PARAMS = new Set([
+    'collectionId',
+    'appId',
+    'productId',
+    'proofId',
+    'isAdmin',
+    'dark',
+    'parentUrl',
+    'theme',
+    'lang',
+]);
+/**
+ * Hook to handle all iframe postMessage communication.
+ *
+ * Handles:
+ * - Route changes (deep linking)
+ * - API proxy requests
+ * - Auth messages (login/logout)
+ * - File uploads (chunked)
+ * - Redirects
+ *
+ * @param iframeRef - Ref to the iframe element
+ * @param options - Configuration and callbacks
+ */
+function useIframeMessages(iframeRef, options) {
+    const { collectionId, productId, proofId, cachedData, login, logout, onRouteChange, onError } = options;
+    // Track uploads in progress
+    const uploadsRef = useRef(new Map());
+    // Track initial load to skip first route change
+    const isInitialLoadRef = useRef(true);
+    // Stable refs to avoid dependency issues
+    const cachedDataRef = useRef(cachedData);
+    const onRouteChangeRef = useRef(onRouteChange);
+    const onErrorRef = useRef(onError);
+    const loginRef = useRef(login);
+    const logoutRef = useRef(logout);
+    // Keep refs in sync
+    useEffect(() => {
+        cachedDataRef.current = cachedData;
+    }, [cachedData]);
+    useEffect(() => {
+        onRouteChangeRef.current = onRouteChange;
+    }, [onRouteChange]);
+    useEffect(() => {
+        onErrorRef.current = onError;
+    }, [onError]);
+    useEffect(() => {
+        loginRef.current = login;
+    }, [login]);
+    useEffect(() => {
+        logoutRef.current = logout;
+    }, [logout]);
+    // Send response back to iframe
+    const sendResponse = useCallback((source, origin, message) => {
+        if (source && 'postMessage' in source) {
+            source.postMessage(message, origin);
+        }
+    }, []);
+    // Handle route change messages (deep linking)
+    const handleRouteChange = useCallback((data) => {
+        // Skip initial load to prevent duplicating path
+        if (isInitialLoadRef.current) {
+            isInitialLoadRef.current = false;
+            return;
+        }
+        const { context = {}, state = {}, path = '' } = data;
+        // Filter out known iframe params, keep only app-specific state
+        const filteredState = {};
+        Object.entries(context).forEach(([key, value]) => {
+            if (value != null && !KNOWN_PARAMS.has(key) && typeof value === 'string') {
+                filteredState[key] = value;
+            }
+        });
+        Object.entries(state).forEach(([key, value]) => {
+            if (value != null && !KNOWN_PARAMS.has(key) && typeof value === 'string') {
+                filteredState[key] = value;
+            }
+        });
+        onRouteChangeRef.current?.(path, filteredState);
+    }, []);
+    // Handle API proxy requests
+    const handleProxyRequest = useCallback(async (data, event) => {
+        const response = {
+            _smartlinksProxyResponse: true,
+            id: data.id,
+        };
+        // Handle custom proxy requests (redirects, etc.)
+        if ('_smartlinksCustomProxyRequest' in data && data._smartlinksCustomProxyRequest) {
+            if (data.request === 'REDIRECT') {
+                const url = data.params?.url;
+                if (typeof url === 'string') {
+                    window.location.href = url;
+                }
+                response.data = { success: true };
+                sendResponse(event.source, event.origin, response);
+                return;
+            }
+        }
+        // Regular proxy request - narrow the type
+        const proxyData = data;
+        try {
+            console.log('[SmartlinksFrame] Proxy request:', proxyData.method, proxyData.path);
+            const path = proxyData.path.startsWith('/') ? proxyData.path.slice(1) : proxyData.path;
+            const cached = cachedDataRef.current;
+            // Check for cached data matches on GET requests
+            if (proxyData.method === 'GET') {
+                // Collection request
+                if (path.includes('/collection/') && cached.collection) {
+                    const collectionIdMatch = path.match(/collection\/([^/]+)/);
+                    if (collectionIdMatch && collectionIdMatch[1] === collectionId) {
+                        response.data = JSON.parse(JSON.stringify(cached.collection));
+                        sendResponse(event.source, event.origin, response);
+                        return;
+                    }
+                }
+                // Product request
+                if (path.includes('/product/') && cached.product && productId) {
+                    const productIdMatch = path.match(/product\/([^/]+)/);
+                    if (productIdMatch && productIdMatch[1] === productId) {
+                        response.data = JSON.parse(JSON.stringify(cached.product));
+                        sendResponse(event.source, event.origin, response);
+                        return;
+                    }
+                }
+                // Proof request
+                if (path.includes('/proof/') && cached.proof && proofId) {
+                    const proofIdMatch = path.match(/proof\/([^/]+)/);
+                    if (proofIdMatch && proofIdMatch[1] === proofId) {
+                        response.data = JSON.parse(JSON.stringify(cached.proof));
+                        sendResponse(event.source, event.origin, response);
+                        return;
+                    }
+                }
+                // Account request
+                if (path.includes('/account') && cached.user) {
+                    response.data = JSON.parse(JSON.stringify({
+                        ...cached.user.accountData,
+                        uid: cached.user.uid,
+                        email: cached.user.email,
+                        displayName: cached.user.displayName,
+                    }));
+                    sendResponse(event.source, event.origin, response);
+                    return;
+                }
+            }
+            // Forward to actual API using SDK's internal request method
+            // Note: The SDK should handle this via proxy mode, but we're explicitly forwarding
+            const apiMethod = proxyData.method.toLowerCase();
+            // Use the SDK's http utilities
+            let result;
+            switch (apiMethod) {
+                case 'get':
+                    result = await smartlinks.http?.get?.(path) ??
+                        await fetch(`/api/v1/${path}`).then(r => r.json());
+                    break;
+                case 'post':
+                    result = await smartlinks.http?.post?.(path, proxyData.body) ??
+                        await fetch(`/api/v1/${path}`, { method: 'POST', body: JSON.stringify(proxyData.body) }).then(r => r.json());
+                    break;
+                case 'put':
+                    result = await smartlinks.http?.put?.(path, proxyData.body) ??
+                        await fetch(`/api/v1/${path}`, { method: 'PUT', body: JSON.stringify(proxyData.body) }).then(r => r.json());
+                    break;
+                case 'patch':
+                    result = await smartlinks.http?.patch?.(path, proxyData.body) ??
+                        await fetch(`/api/v1/${path}`, { method: 'PATCH', body: JSON.stringify(proxyData.body) }).then(r => r.json());
+                    break;
+                case 'delete':
+                    result = await smartlinks.http?.delete?.(path) ??
+                        await fetch(`/api/v1/${path}`, { method: 'DELETE' }).then(r => r.json());
+                    break;
+            }
+            response.data = result;
+        }
+        catch (err) {
+            console.error('[SmartlinksFrame] Proxy error:', err);
+            response.error = err?.message || 'Unknown error';
+            onErrorRef.current?.(err);
+        }
+        sendResponse(event.source, event.origin, response);
+    }, [collectionId, productId, proofId, sendResponse]);
+    // Handle standardized iframe messages (auth, resize, redirect)
+    const handleStandardMessage = useCallback(async (data, event) => {
+        console.log('[SmartlinksFrame] Iframe message:', data.type);
+        switch (data.type) {
+            case 'smartlinks:resize': {
+                // Handled by useIframeResize hook
+                break;
+            }
+            case 'smartlinks:redirect': {
+                const url = data.payload?.url;
+                if (url && typeof url === 'string') {
+                    window.location.href = url;
+                }
+                break;
+            }
+            case 'smartlinks:authkit:login': {
+                const { token, user: iframeUser, accountData, messageId } = data.payload || {};
+                // If no login function available (no AuthProvider), just acknowledge
+                if (!loginRef.current) {
+                    console.log('[SmartlinksFrame] No AuthProvider - ignoring auth login');
+                    sendResponse(event.source, event.origin, {
+                        type: 'smartlinks:authkit:login-acknowledged',
+                        messageId,
+                        success: false,
+                        error: 'No AuthProvider available',
+                    });
+                    break;
+                }
+                try {
+                    // Validate token using SDK
+                    console.log('[SmartlinksFrame] Validating auth token...');
+                    if (typeof token === 'string') {
+                        await smartlinks.auth.verifyToken(token);
+                    }
+                    // Cast user to expected shape
+                    const userPayload = iframeUser;
+                    // Validate user object has required properties
+                    const authUser = {
+                        uid: userPayload?.uid || '',
+                        email: userPayload?.email,
+                        displayName: userPayload?.displayName,
+                        accountData: accountData || userPayload?.accountData,
+                    };
+                    // Use AuthProvider's login to persist session
+                    await loginRef.current(token, authUser, accountData);
+                    // Send acknowledgment
+                    sendResponse(event.source, event.origin, {
+                        type: 'smartlinks:authkit:login-acknowledged',
+                        messageId,
+                        success: true,
+                    });
+                    console.log('[SmartlinksFrame] Auth login acknowledged');
+                }
+                catch (err) {
+                    console.error('[SmartlinksFrame] Auth login failed:', err);
+                    sendResponse(event.source, event.origin, {
+                        type: 'smartlinks:authkit:login-acknowledged',
+                        messageId,
+                        success: false,
+                        error: err?.message || 'Token validation failed',
+                    });
+                    onErrorRef.current?.(err);
+                }
+                break;
+            }
+            case 'smartlinks:authkit:logout': {
+                console.log('[SmartlinksFrame] Processing logout from iframe');
+                if (logoutRef.current) {
+                    await logoutRef.current();
+                }
+                else {
+                    console.log('[SmartlinksFrame] No AuthProvider - ignoring logout');
+                }
+                break;
+            }
+            case 'smartlinks:authkit:redirect': {
+                const url = data.payload?.url;
+                if (url && typeof url === 'string') {
+                    window.location.href = url;
+                }
+                break;
+            }
+        }
+    }, [sendResponse]);
+    // Handle chunked file uploads
+    const handleUpload = useCallback(async (data, event) => {
+        const uploads = uploadsRef.current;
+        switch (data.phase) {
+            case 'start': {
+                const startData = data;
+                uploads.set(startData.id, {
+                    chunks: [],
+                    fields: startData.fields,
+                    fileInfo: startData.fileInfo,
+                    path: startData.path,
+                });
+                break;
+            }
+            case 'chunk': {
+                const chunkData = data;
+                const upload = uploads.get(chunkData.id);
+                if (upload) {
+                    // Convert ArrayBuffer to Uint8Array and store as regular array buffer
+                    const uint8Array = new Uint8Array(chunkData.chunk);
+                    upload.chunks.push(uint8Array);
+                    sendResponse(event.source, event.origin, {
+                        _smartlinksProxyUpload: true,
+                        phase: 'ack',
+                        id: chunkData.id,
+                        seq: chunkData.seq,
+                    });
+                }
+                break;
+            }
+            case 'end': {
+                const endData = data;
+                const upload = uploads.get(endData.id);
+                if (!upload)
+                    break;
+                try {
+                    // Reconstruct file from chunks - convert to regular arrays for Blob
+                    const blobParts = upload.chunks.map(chunk => chunk.buffer.slice(0));
+                    const blob = new Blob(blobParts, {
+                        type: upload.fileInfo.type || 'application/octet-stream'
+                    });
+                    const formData = new FormData();
+                    upload.fields.forEach(([key, value]) => formData.append(key, value));
+                    formData.append(upload.fileInfo.key || 'file', blob, upload.fileInfo.name || 'upload.bin');
+                    // Upload via SDK or direct fetch
+                    const path = upload.path.startsWith('/') ? upload.path.slice(1) : upload.path;
+                    const baseUrl = smartlinks.getBaseUrl?.() || '/api/v1';
+                    const response = await fetch(`${baseUrl}/${path}`, {
+                        method: 'POST',
+                        body: formData,
+                        // Let browser set Content-Type with boundary
+                    });
+                    if (!response.ok) {
+                        throw new Error(`Upload failed: ${response.status}`);
+                    }
+                    const result = await response.json();
+                    sendResponse(event.source, event.origin, {
+                        _smartlinksProxyUpload: true,
+                        phase: 'done',
+                        id: endData.id,
+                        ok: true,
+                        data: result,
+                    });
+                }
+                catch (err) {
+                    console.error('[SmartlinksFrame] Upload failed:', err);
+                    sendResponse(event.source, event.origin, {
+                        _smartlinksProxyUpload: true,
+                        phase: 'done',
+                        id: endData.id,
+                        ok: false,
+                        error: err?.message || 'Upload failed',
+                    });
+                    onErrorRef.current?.(err);
+                }
+                uploads.delete(endData.id);
+                break;
+            }
+        }
+    }, [sendResponse]);
+    // Main message handler
+    useEffect(() => {
+        const handleMessage = async (event) => {
+            // Validate source is our iframe
+            if (!iframeRef.current || event.source !== iframeRef.current.contentWindow) {
+                return;
+            }
+            const data = event.data;
+            if (!data || typeof data !== 'object')
+                return;
+            // Route changes (deep linking)
+            if (data.type === 'smartlinks-route-change') {
+                handleRouteChange(data);
+                return;
+            }
+            // Standardized iframe messages
+            if (data._smartlinksIframeMessage) {
+                await handleStandardMessage(data, event);
+                return;
+            }
+            // File upload proxy
+            if (data._smartlinksProxyUpload) {
+                await handleUpload(data, event);
+                return;
+            }
+            // API proxy requests
+            if (data._smartlinksProxyRequest) {
+                await handleProxyRequest(data, event);
+                return;
+            }
+        };
+        window.addEventListener('message', handleMessage);
+        return () => window.removeEventListener('message', handleMessage);
+    }, [iframeRef, handleRouteChange, handleStandardMessage, handleUpload, handleProxyRequest]);
+}
+
 const ProtectedRoute = ({ children, fallback, redirectTo, }) => {
     const { isAuthenticated, isLoading } = useAuth();
     // Show loading state
@@ -14380,5 +15048,5 @@ async function setDefaultAuthKitId(collectionId, authKitId) {
     });
 }
 
-export { AccountManagement, AuthProvider, AuthUIPreview, SmartlinksAuthUI as FirebaseAuthUI, ProtectedRoute, SchemaFieldRenderer, SmartlinksAuthUI, getDefaultAuthKitId, getEditableFields, getErrorCode, getErrorStatusCode, getFriendlyErrorMessage, getRegistrationFields, isAuthError, isConflictError, isRateLimitError, isServerError, setDefaultAuthKitId, sortFieldsByPlacement, tokenStorage, useAuth };
+export { AccountManagement, AuthProvider, AuthUIPreview, SmartlinksAuthUI as FirebaseAuthUI, ProtectedRoute, SchemaFieldRenderer, SmartlinksAuthUI, SmartlinksFrame, buildIframeSrc, getDefaultAuthKitId, getEditableFields, getErrorCode, getErrorStatusCode, getFriendlyErrorMessage, getRegistrationFields, isAdminFromRoles, isAuthError, isConflictError, isRateLimitError, isServerError, setDefaultAuthKitId, sortFieldsByPlacement, tokenStorage, useAdminDetection, useAuth, useIframeMessages, useIframeResize };
 //# sourceMappingURL=index.esm.js.map