@oxyhq/auth 1.0.0

package/dist/cjs/hooks/useFileDownloadUrl.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFileDownloadUrl = exports.setOxyFileUrlInstance = void 0;
+const react_1 = require("react");
+let oxyInstance = null;
+const setOxyFileUrlInstance = (instance) => {
+    oxyInstance = instance;
+};
+exports.setOxyFileUrlInstance = setOxyFileUrlInstance;
+/**
+ * Hook to resolve a file's download URL asynchronously.
+ *
+ * Prefers `getFileDownloadUrlAsync` and falls back to the synchronous
+ * `getFileDownloadUrl` helper if the async call fails.
+ */
+const useFileDownloadUrl = (fileId, options) => {
+    const [url, setUrl] = (0, react_1.useState)(null);
+    const [loading, setLoading] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    (0, react_1.useEffect)(() => {
+        if (!fileId) {
+            setUrl(null);
+            setLoading(false);
+            setError(null);
+            return;
+        }
+        if (!oxyInstance) {
+            // Fail silently but don't crash the UI – caller can decide what to do with null URL.
+            setUrl(null);
+            setLoading(false);
+            setError(new Error('OxyServices instance not configured for useFileDownloadUrl'));
+            return;
+        }
+        let cancelled = false;
+        const load = async () => {
+            setLoading(true);
+            setError(null);
+            // Store instance in local variable for TypeScript null checking
+            const instance = oxyInstance;
+            if (!instance) {
+                setLoading(false);
+                setError(new Error('OxyServices instance not configured for useFileDownloadUrl'));
+                return;
+            }
+            try {
+                const { variant, expiresIn } = options || {};
+                let resolvedUrl = null;
+                if (typeof instance.getFileDownloadUrlAsync === 'function') {
+                    resolvedUrl = await instance.getFileDownloadUrlAsync(fileId, variant, expiresIn);
+                }
+                if (!resolvedUrl && typeof instance.getFileDownloadUrl === 'function') {
+                    resolvedUrl = instance.getFileDownloadUrl(fileId, variant, expiresIn);
+                }
+                if (!cancelled) {
+                    setUrl(resolvedUrl || null);
+                }
+            }
+            catch (err) {
+                // Fallback to sync URL on error where possible
+                try {
+                    if (typeof instance.getFileDownloadUrl === 'function') {
+                        const { variant, expiresIn } = options || {};
+                        const fallbackUrl = instance.getFileDownloadUrl(fileId, variant, expiresIn);
+                        if (!cancelled) {
+                            setUrl(fallbackUrl || null);
+                            setError(err instanceof Error ? err : new Error(String(err)));
+                        }
+                        return;
+                    }
+                }
+                catch {
+                    // ignore secondary failure, we'll surface the original error below
+                }
+                if (!cancelled) {
+                    setError(err instanceof Error ? err : new Error(String(err)));
+                }
+            }
+            finally {
+                if (!cancelled) {
+                    setLoading(false);
+                }
+            }
+        };
+        load();
+        return () => {
+            cancelled = true;
+        };
+    }, [fileId, options?.variant, options?.expiresIn]);
+    return { url, loading, error };
+};
+exports.useFileDownloadUrl = useFileDownloadUrl;

package/dist/cjs/hooks/useFileFiltering.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFileFiltering = useFileFiltering;
+const react_1 = require("react");
+/**
+ * Hook for file filtering, sorting, and search functionality
+ * Extracts common file management logic for reuse across components
+ */
+function useFileFiltering({ files, initialViewMode = 'all', initialSortBy = 'date', initialSortOrder = 'desc', }) {
+    const [viewMode, setViewMode] = (0, react_1.useState)(initialViewMode);
+    const [searchQuery, setSearchQuery] = (0, react_1.useState)('');
+    const [sortBy, setSortBy] = (0, react_1.useState)(initialSortBy);
+    const [sortOrder, setSortOrder] = (0, react_1.useState)(initialSortOrder);
+    const toggleSortOrder = (0, react_1.useCallback)(() => {
+        setSortOrder((prev) => (prev === 'asc' ? 'desc' : 'asc'));
+    }, []);
+    const filteredFiles = (0, react_1.useMemo)(() => {
+        // Filter by view mode
+        let filteredByMode = files;
+        if (viewMode === 'photos') {
+            filteredByMode = files.filter((file) => file.contentType.startsWith('image/'));
+        }
+        else if (viewMode === 'videos') {
+            filteredByMode = files.filter((file) => file.contentType.startsWith('video/'));
+        }
+        else if (viewMode === 'documents') {
+            filteredByMode = files.filter((file) => file.contentType.includes('pdf') ||
+                file.contentType.includes('document') ||
+                file.contentType.includes('text') ||
+                file.contentType.includes('msword') ||
+                file.contentType.includes('excel') ||
+                file.contentType.includes('spreadsheet') ||
+                file.contentType.includes('presentation') ||
+                file.contentType.includes('powerpoint'));
+        }
+        else if (viewMode === 'audio') {
+            filteredByMode = files.filter((file) => file.contentType.startsWith('audio/'));
+        }
+        // Filter by search query
+        let filtered = filteredByMode;
+        if (searchQuery.trim()) {
+            const query = searchQuery.toLowerCase();
+            filtered = filteredByMode.filter((file) => file.filename.toLowerCase().includes(query) ||
+                file.contentType.toLowerCase().includes(query) ||
+                (file.metadata?.description &&
+                    file.metadata.description.toLowerCase().includes(query)));
+        }
+        // Sort files
+        const sorted = [...filtered].sort((a, b) => {
+            let comparison = 0;
+            if (sortBy === 'date') {
+                const dateA = new Date(a.uploadDate || 0).getTime();
+                const dateB = new Date(b.uploadDate || 0).getTime();
+                comparison = dateA - dateB;
+            }
+            else if (sortBy === 'size') {
+                comparison = (a.length || 0) - (b.length || 0);
+            }
+            else if (sortBy === 'name') {
+                comparison = (a.filename || '').localeCompare(b.filename || '');
+            }
+            else if (sortBy === 'type') {
+                comparison = (a.contentType || '').localeCompare(b.contentType || '');
+            }
+            return sortOrder === 'asc' ? comparison : -comparison;
+        });
+        return sorted;
+    }, [files, searchQuery, viewMode, sortBy, sortOrder]);
+    return {
+        filteredFiles,
+        viewMode,
+        setViewMode,
+        searchQuery,
+        setSearchQuery,
+        sortBy,
+        setSortBy,
+        sortOrder,
+        setSortOrder,
+        toggleSortOrder,
+    };
+}

package/dist/cjs/hooks/useFollow.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFollowerCounts = exports.useFollow = void 0;
+const react_1 = require("react");
+const followStore_1 = require("../stores/followStore");
+const WebOxyProvider_1 = require("../WebOxyProvider");
+const useFollow = (userId) => {
+    const { oxyServices } = (0, WebOxyProvider_1.useWebOxy)();
+    const userIds = (0, react_1.useMemo)(() => (Array.isArray(userId) ? userId : userId ? [userId] : []), [userId]);
+    const isSingleUser = typeof userId === 'string';
+    // Zustand selectors
+    const followState = (0, followStore_1.useFollowStore)();
+    // Single user helpers
+    const isFollowing = isSingleUser && userId ? followState.followingUsers[userId] ?? false : false;
+    const isLoading = isSingleUser && userId ? followState.loadingUsers[userId] ?? false : false;
+    const error = isSingleUser && userId ? followState.errors[userId] ?? null : null;
+    // Follower count helpers
+    const followerCount = isSingleUser && userId ? followState.followerCounts[userId] ?? null : null;
+    const followingCount = isSingleUser && userId ? followState.followingCounts[userId] ?? null : null;
+    const isLoadingCounts = isSingleUser && userId ? followState.loadingCounts[userId] ?? false : false;
+    const toggleFollow = (0, react_1.useCallback)(async () => {
+        if (!isSingleUser || !userId)
+            throw new Error('toggleFollow is only available for single user mode');
+        await followState.toggleFollowUser(userId, oxyServices, isFollowing);
+    }, [isSingleUser, userId, followState, oxyServices, isFollowing]);
+    const setFollowStatus = (0, react_1.useCallback)((following) => {
+        if (!isSingleUser || !userId)
+            throw new Error('setFollowStatus is only available for single user mode');
+        followState.setFollowingStatus(userId, following);
+    }, [isSingleUser, userId, followState]);
+    const fetchStatus = (0, react_1.useCallback)(async () => {
+        if (!isSingleUser || !userId)
+            throw new Error('fetchStatus is only available for single user mode');
+        await followState.fetchFollowStatus(userId, oxyServices);
+    }, [isSingleUser, userId, followState, oxyServices]);
+    const clearError = (0, react_1.useCallback)(() => {
+        if (!isSingleUser || !userId)
+            throw new Error('clearError is only available for single user mode');
+        followState.clearFollowError(userId);
+    }, [isSingleUser, userId, followState]);
+    const fetchUserCounts = (0, react_1.useCallback)(async () => {
+        if (!isSingleUser || !userId)
+            throw new Error('fetchUserCounts is only available for single user mode');
+        await followState.fetchUserCounts(userId, oxyServices);
+    }, [isSingleUser, userId, followState, oxyServices]);
+    const setFollowerCount = (0, react_1.useCallback)((count) => {
+        if (!isSingleUser || !userId)
+            throw new Error('setFollowerCount is only available for single user mode');
+        followState.setFollowerCount(userId, count);
+    }, [isSingleUser, userId, followState]);
+    const setFollowingCount = (0, react_1.useCallback)((count) => {
+        if (!isSingleUser || !userId)
+            throw new Error('setFollowingCount is only available for single user mode');
+        followState.setFollowingCount(userId, count);
+    }, [isSingleUser, userId, followState]);
+    // Auto-fetch counts when hook is used for a single user and counts are missing.
+    (0, react_1.useEffect)(() => {
+        if (!isSingleUser || !userId)
+            return;
+        // If either count is not set and we're not already loading counts, trigger a fetch.
+        if ((followerCount === null || followingCount === null) && !isLoadingCounts) {
+            fetchUserCounts().catch((err) => console.warn('useFollow: fetchUserCounts failed', err));
+        }
+    }, [isSingleUser, userId, followerCount, followingCount, isLoadingCounts, fetchUserCounts]);
+    // Multiple user helpers
+    const followData = (0, react_1.useMemo)(() => {
+        const data = {};
+        userIds.forEach(uid => {
+            data[uid] = {
+                isFollowing: followState.followingUsers[uid] ?? false,
+                isLoading: followState.loadingUsers[uid] ?? false,
+                error: followState.errors[uid] ?? null,
+            };
+        });
+        return data;
+    }, [userIds, followState.followingUsers, followState.loadingUsers, followState.errors]);
+    const toggleFollowForUser = (0, react_1.useCallback)(async (targetUserId) => {
+        const currentState = followState.followingUsers[targetUserId] ?? false;
+        await followState.toggleFollowUser(targetUserId, oxyServices, currentState);
+    }, [followState, oxyServices]);
+    const setFollowStatusForUser = (0, react_1.useCallback)((targetUserId, following) => {
+        followState.setFollowingStatus(targetUserId, following);
+    }, [followState]);
+    const fetchStatusForUser = (0, react_1.useCallback)(async (targetUserId) => {
+        await followState.fetchFollowStatus(targetUserId, oxyServices);
+    }, [followState, oxyServices]);
+    const fetchAllStatuses = (0, react_1.useCallback)(async () => {
+        await Promise.all(userIds.map(uid => followState.fetchFollowStatus(uid, oxyServices)));
+    }, [userIds, followState, oxyServices]);
+    const clearErrorForUser = (0, react_1.useCallback)((targetUserId) => {
+        followState.clearFollowError(targetUserId);
+    }, [followState]);
+    const updateCountsFromFollowAction = (0, react_1.useCallback)((targetUserId, action, counts) => {
+        const currentUserId = oxyServices.getCurrentUserId() || undefined;
+        followState.updateCountsFromFollowAction(targetUserId, action, counts, currentUserId);
+    }, [followState, oxyServices]);
+    // Aggregate helpers for multiple users
+    const isAnyLoading = userIds.some(uid => followState.loadingUsers[uid]);
+    const hasAnyError = userIds.some(uid => !!followState.errors[uid]);
+    const allFollowing = userIds.every(uid => followState.followingUsers[uid]);
+    const allNotFollowing = userIds.every(uid => !followState.followingUsers[uid]);
+    if (isSingleUser && userId) {
+        return {
+            isFollowing,
+            isLoading,
+            error,
+            toggleFollow,
+            setFollowStatus,
+            fetchStatus,
+            clearError,
+            // Follower count methods
+            followerCount,
+            followingCount,
+            isLoadingCounts,
+            fetchUserCounts,
+            setFollowerCount,
+            setFollowingCount,
+        };
+    }
+    return {
+        followData,
+        toggleFollowForUser,
+        setFollowStatusForUser,
+        fetchStatusForUser,
+        fetchAllStatuses,
+        clearErrorForUser,
+        isAnyLoading,
+        hasAnyError,
+        allFollowing,
+        allNotFollowing,
+    };
+};
+exports.useFollow = useFollow;
+// Convenience hook for just follower counts
+const useFollowerCounts = (userId) => {
+    const { oxyServices } = (0, WebOxyProvider_1.useWebOxy)();
+    const followState = (0, followStore_1.useFollowStore)();
+    const followerCount = followState.followerCounts[userId] ?? null;
+    const followingCount = followState.followingCounts[userId] ?? null;
+    const isLoadingCounts = followState.loadingCounts[userId] ?? false;
+    const fetchUserCounts = (0, react_1.useCallback)(async () => {
+        await followState.fetchUserCounts(userId, oxyServices);
+    }, [userId, followState, oxyServices]);
+    const setFollowerCount = (0, react_1.useCallback)((count) => {
+        followState.setFollowerCount(userId, count);
+    }, [userId, followState]);
+    const setFollowingCount = (0, react_1.useCallback)((count) => {
+        followState.setFollowingCount(userId, count);
+    }, [userId, followState]);
+    return {
+        followerCount,
+        followingCount,
+        isLoadingCounts,
+        fetchUserCounts,
+        setFollowerCount,
+        setFollowingCount,
+    };
+};
+exports.useFollowerCounts = useFollowerCounts;

package/dist/cjs/hooks/useFollow.types.js

@@ -0,0 +1,4 @@
+"use strict";
+// Type-only definition for the useFollow hook to allow context exposure without runtime import cycles.
+// Expand this as needed to better reflect the real return type.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/hooks/useQueryClient.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useQueryClient = void 0;
+const react_query_1 = require("@tanstack/react-query");
+/**
+ * Custom hook to access the QueryClient
+ * Provides type safety and ensures client is available
+ */
+const useQueryClient = () => {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    if (!queryClient) {
+        throw new Error('QueryClient is not available. Make sure OxyProvider is wrapping your app.');
+    }
+    return queryClient;
+};
+exports.useQueryClient = useQueryClient;

package/dist/cjs/hooks/useSessionSocket.js

@@ -0,0 +1,215 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSessionSocket = useSessionSocket;
+const react_1 = require("react");
+const socket_io_client_1 = __importDefault(require("socket.io-client"));
+const sonner_1 = require("sonner");
+const core_1 = require("@oxyhq/core");
+const core_2 = require("@oxyhq/core");
+const debug = (0, core_2.createDebugLogger)('SessionSocket');
+function useSessionSocket({ userId, activeSessionId, currentDeviceId, refreshSessions, logout, clearSessionState, baseURL, onRemoteSignOut, onSessionRemoved }) {
+    const socketRef = (0, react_1.useRef)(null);
+    const joinedRoomRef = (0, react_1.useRef)(null);
+    // Store callbacks in refs to avoid re-joining when they change
+    const refreshSessionsRef = (0, react_1.useRef)(refreshSessions);
+    const logoutRef = (0, react_1.useRef)(logout);
+    const clearSessionStateRef = (0, react_1.useRef)(clearSessionState);
+    const onRemoteSignOutRef = (0, react_1.useRef)(onRemoteSignOut);
+    const onSessionRemovedRef = (0, react_1.useRef)(onSessionRemoved);
+    const activeSessionIdRef = (0, react_1.useRef)(activeSessionId);
+    const currentDeviceIdRef = (0, react_1.useRef)(currentDeviceId);
+    // Update refs when callbacks change
+    (0, react_1.useEffect)(() => {
+        refreshSessionsRef.current = refreshSessions;
+        logoutRef.current = logout;
+        clearSessionStateRef.current = clearSessionState;
+        onRemoteSignOutRef.current = onRemoteSignOut;
+        onSessionRemovedRef.current = onSessionRemoved;
+        activeSessionIdRef.current = activeSessionId;
+        currentDeviceIdRef.current = currentDeviceId;
+    }, [refreshSessions, logout, clearSessionState, onRemoteSignOut, onSessionRemoved, activeSessionId, currentDeviceId]);
+    (0, react_1.useEffect)(() => {
+        if (!userId || !baseURL) {
+            // Clean up if userId or baseURL becomes invalid
+            if (socketRef.current && joinedRoomRef.current) {
+                socketRef.current.emit('leave', { userId: joinedRoomRef.current });
+                joinedRoomRef.current = null;
+            }
+            return;
+        }
+        const roomId = `user:${userId}`;
+        // Only create socket if it doesn't exist
+        if (!socketRef.current) {
+            socketRef.current = (0, socket_io_client_1.default)(baseURL, {
+                transports: ['websocket'],
+            });
+        }
+        const socket = socketRef.current;
+        // Only join if we haven't already joined this room
+        if (joinedRoomRef.current !== roomId) {
+            // Leave previous room if switching users
+            if (joinedRoomRef.current) {
+                socket.emit('leave', { userId: joinedRoomRef.current });
+            }
+            socket.emit('join', { userId: roomId });
+            joinedRoomRef.current = roomId;
+            debug.log('Emitting join for room:', roomId);
+        }
+        // Set up event handlers (only once per socket instance)
+        const handleConnect = () => {
+            debug.log('Socket connected:', socket.id);
+        };
+        const handleSessionUpdate = async (data) => {
+            debug.log('Received session_update:', data);
+            const currentActiveSessionId = activeSessionIdRef.current;
+            const currentDeviceId = currentDeviceIdRef.current;
+            // Handle different event types
+            if (data.type === 'session_removed') {
+                // Track removed session
+                if (data.sessionId && onSessionRemovedRef.current) {
+                    onSessionRemovedRef.current(data.sessionId);
+                }
+                // If the removed sessionId matches the current activeSessionId, immediately clear state
+                if (data.sessionId === currentActiveSessionId) {
+                    if (onRemoteSignOutRef.current) {
+                        onRemoteSignOutRef.current();
+                    }
+                    else {
+                        sonner_1.toast.info('You have been signed out remotely.');
+                    }
+                    // Use clearSessionState since session was already removed server-side
+                    // Await to ensure storage cleanup completes before continuing
+                    try {
+                        await clearSessionStateRef.current();
+                    }
+                    catch (error) {
+                        if (__DEV__) {
+                            core_1.logger.error('Failed to clear session state after session_removed', error instanceof Error ? error : new Error(String(error)), { component: 'useSessionSocket' });
+                        }
+                    }
+                }
+                else {
+                    // Otherwise, just refresh the sessions list (with error handling)
+                    refreshSessionsRef.current().catch((error) => {
+                        // Silently handle errors from refresh - they're expected if sessions were removed
+                        if (__DEV__) {
+                            core_1.logger.debug('Failed to refresh sessions after session_removed', { component: 'useSessionSocket' }, error);
+                        }
+                    });
+                }
+            }
+            else if (data.type === 'device_removed') {
+                // Track all removed sessions from this device
+                if (data.sessionIds && onSessionRemovedRef.current) {
+                    for (const sessionId of data.sessionIds) {
+                        onSessionRemovedRef.current(sessionId);
+                    }
+                }
+                // If the removed deviceId matches the current device, immediately clear state
+                if (data.deviceId && data.deviceId === currentDeviceId) {
+                    if (onRemoteSignOutRef.current) {
+                        onRemoteSignOutRef.current();
+                    }
+                    else {
+                        sonner_1.toast.info('This device has been removed. You have been signed out.');
+                    }
+                    // Use clearSessionState since sessions were already removed server-side
+                    // Await to ensure storage cleanup completes before continuing
+                    try {
+                        await clearSessionStateRef.current();
+                    }
+                    catch (error) {
+                        if (__DEV__) {
+                            core_1.logger.error('Failed to clear session state after device_removed', error instanceof Error ? error : new Error(String(error)), { component: 'useSessionSocket' });
+                        }
+                    }
+                }
+                else {
+                    // Otherwise, refresh sessions and device list (with error handling)
+                    refreshSessionsRef.current().catch((error) => {
+                        // Silently handle errors from refresh - they're expected if sessions were removed
+                        if (__DEV__) {
+                            core_1.logger.debug('Failed to refresh sessions after device_removed', { component: 'useSessionSocket' }, error);
+                        }
+                    });
+                }
+            }
+            else if (data.type === 'sessions_removed') {
+                // Track all removed sessions
+                if (data.sessionIds && onSessionRemovedRef.current) {
+                    for (const sessionId of data.sessionIds) {
+                        onSessionRemovedRef.current(sessionId);
+                    }
+                }
+                // If the current activeSessionId is in the removed sessionIds list, immediately clear state
+                if (data.sessionIds && currentActiveSessionId && data.sessionIds.includes(currentActiveSessionId)) {
+                    if (onRemoteSignOutRef.current) {
+                        onRemoteSignOutRef.current();
+                    }
+                    else {
+                        sonner_1.toast.info('You have been signed out remotely.');
+                    }
+                    // Use clearSessionState since sessions were already removed server-side
+                    // Await to ensure storage cleanup completes before continuing
+                    try {
+                        await clearSessionStateRef.current();
+                    }
+                    catch (error) {
+                        if (__DEV__) {
+                            core_1.logger.error('Failed to clear session state after sessions_removed', error instanceof Error ? error : new Error(String(error)), { component: 'useSessionSocket' });
+                        }
+                    }
+                }
+                else {
+                    // Otherwise, refresh sessions list (with error handling)
+                    refreshSessionsRef.current().catch((error) => {
+                        // Silently handle errors from refresh - they're expected if sessions were removed
+                        if (__DEV__) {
+                            core_1.logger.debug('Failed to refresh sessions after sessions_removed', { component: 'useSessionSocket' }, error);
+                        }
+                    });
+                }
+            }
+            else {
+                // For other event types (e.g., session_created), refresh sessions (with error handling)
+                refreshSessionsRef.current().catch((error) => {
+                    // Log but don't throw - refresh errors shouldn't break the socket handler
+                    if (__DEV__) {
+                        core_1.logger.debug('Failed to refresh sessions after session_update', { component: 'useSessionSocket' }, error);
+                    }
+                });
+                // If the current session was logged out (legacy behavior), handle it specially
+                if (data.sessionId === currentActiveSessionId) {
+                    if (onRemoteSignOutRef.current) {
+                        onRemoteSignOutRef.current();
+                    }
+                    else {
+                        sonner_1.toast.info('You have been signed out remotely.');
+                    }
+                    // Use clearSessionState since session was already removed server-side
+                    // Await to ensure storage cleanup completes before continuing
+                    try {
+                        await clearSessionStateRef.current();
+                    }
+                    catch (error) {
+                        debug.error('Failed to clear session state after session_update:', error);
+                    }
+                }
+            }
+        };
+        socket.on('connect', handleConnect);
+        socket.on('session_update', handleSessionUpdate);
+        return () => {
+            socket.off('connect', handleConnect);
+            socket.off('session_update', handleSessionUpdate);
+            // Only leave on unmount if we're still in this room
+            if (joinedRoomRef.current === roomId) {
+                socket.emit('leave', { userId: roomId });
+                joinedRoomRef.current = null;
+            }
+        };
+    }, [userId, baseURL]); // Only depend on userId and baseURL - callbacks are in refs
+}