@oxyhq/services 6.9.13 → 6.9.15

package/src/ui/hooks/useDeviceManagement.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDeviceManagement = void 0;
+const react_1 = require("react");
+const core_1 = require("@oxyhq/core");
+const errorHandlers_1 = require("../utils/errorHandlers");
+/**
+ * Provide device session management helpers tied to the current active session.
+ *
+ * @param options - Device management configuration
+ */
+const useDeviceManagement = ({ oxyServices, activeSessionId, onError, clearSessionState, logger, }) => {
+    const getDeviceSessions = (0, react_1.useCallback)(async () => {
+        if (!activeSessionId)
+            throw new Error('No active session');
+        try {
+            return await oxyServices.getDeviceSessions(activeSessionId);
+        }
+        catch (error) {
+            (0, errorHandlers_1.handleAuthError)(error, {
+                defaultMessage: 'Failed to get device sessions',
+                code: 'GET_DEVICE_SESSIONS_ERROR',
+                onError,
+                logger,
+            });
+            throw error instanceof Error ? error : new Error('Failed to get device sessions');
+        }
+    }, [activeSessionId, logger, onError, oxyServices]);
+    const logoutAllDeviceSessions = (0, react_1.useCallback)(async () => {
+        if (!activeSessionId)
+            throw new Error('No active session');
+        try {
+            await oxyServices.logoutAllDeviceSessions(activeSessionId);
+            await clearSessionState();
+        }
+        catch (error) {
+            (0, errorHandlers_1.handleAuthError)(error, {
+                defaultMessage: 'Failed to logout all device sessions',
+                code: 'LOGOUT_ALL_DEVICES_ERROR',
+                onError,
+                logger,
+            });
+            throw error instanceof Error ? error : new Error('Failed to logout all device sessions');
+        }
+    }, [activeSessionId, clearSessionState, logger, onError, oxyServices]);
+    const updateDeviceName = (0, react_1.useCallback)(async (deviceName) => {
+        if (!activeSessionId)
+            throw new Error('No active session');
+        try {
+            await oxyServices.updateDeviceName(activeSessionId, deviceName);
+            await core_1.DeviceManager.updateDeviceName(deviceName);
+        }
+        catch (error) {
+            (0, errorHandlers_1.handleAuthError)(error, {
+                defaultMessage: 'Failed to update device name',
+                code: 'UPDATE_DEVICE_NAME_ERROR',
+                onError,
+                logger,
+            });
+            throw error instanceof Error ? error : new Error('Failed to update device name');
+        }
+    }, [activeSessionId, logger, onError, oxyServices]);
+    return {
+        getDeviceSessions,
+        logoutAllDeviceSessions,
+        updateDeviceName,
+    };
+};
+exports.useDeviceManagement = useDeviceManagement;

package/src/ui/hooks/useFileDownloadUrl.d.ts

@@ -0,0 +1,21 @@
+import { OxyServices } from '@oxyhq/core';
+export declare const setOxyFileUrlInstance: (instance: OxyServices) => void;
+export interface UseFileDownloadUrlOptions {
+    variant?: string;
+    expiresIn?: number;
+}
+export interface UseFileDownloadUrlResult {
+    url: string | null;
+    loading: boolean;
+    error: Error | null;
+}
+/**
+ * Hook to resolve a file's download URL asynchronously.
+ *
+ * Prefers the provided `oxyServices` instance, falls back to the module-level
+ * singleton set via `setOxyFileUrlInstance`.
+ *
+ * Uses `getFileDownloadUrlAsync` first, falling back to the synchronous
+ * `getFileDownloadUrl` if the async call fails.
+ */
+export declare const useFileDownloadUrl: (fileIdOrServices?: string | OxyServices | null, fileIdOrOptions?: string | UseFileDownloadUrlOptions | null, maybeOptions?: UseFileDownloadUrlOptions) => UseFileDownloadUrlResult;

package/src/ui/hooks/useFileDownloadUrl.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFileDownloadUrl = exports.setOxyFileUrlInstance = void 0;
+const react_1 = require("react");
+const core_1 = require("@oxyhq/core");
+let oxyInstance = null;
+const setOxyFileUrlInstance = (instance) => {
+    oxyInstance = instance;
+};
+exports.setOxyFileUrlInstance = setOxyFileUrlInstance;
+/**
+ * Hook to resolve a file's download URL asynchronously.
+ *
+ * Prefers the provided `oxyServices` instance, falls back to the module-level
+ * singleton set via `setOxyFileUrlInstance`.
+ *
+ * Uses `getFileDownloadUrlAsync` first, falling back to the synchronous
+ * `getFileDownloadUrl` if the async call fails.
+ */
+const useFileDownloadUrl = (fileIdOrServices, fileIdOrOptions, maybeOptions) => {
+    // Support two call signatures:
+    // 1. useFileDownloadUrl(oxyServices, fileId, options)  — preferred
+    // 2. useFileDownloadUrl(fileId, options)               — legacy (uses singleton)
+    let services;
+    let fileId;
+    let options;
+    if (fileIdOrServices instanceof core_1.OxyServices) {
+        services = fileIdOrServices;
+        fileId = typeof fileIdOrOptions === 'string' ? fileIdOrOptions : null;
+        options = maybeOptions;
+    }
+    else {
+        services = oxyInstance;
+        fileId = typeof fileIdOrServices === 'string' ? fileIdOrServices : null;
+        options = typeof fileIdOrOptions === 'object' && fileIdOrOptions !== null ? fileIdOrOptions : undefined;
+    }
+    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 (!services) {
+            setUrl(null);
+            setLoading(false);
+            setError(new Error('OxyServices instance not configured for useFileDownloadUrl'));
+            return;
+        }
+        let cancelled = false;
+        const instance = services;
+        const load = async () => {
+            setLoading(true);
+            setError(null);
+            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
+                }
+                if (!cancelled) {
+                    setError(err instanceof Error ? err : new Error(String(err)));
+                }
+            }
+            finally {
+                if (!cancelled) {
+                    setLoading(false);
+                }
+            }
+        };
+        load();
+        return () => {
+            cancelled = true;
+        };
+    }, [fileId, services, options?.variant, options?.expiresIn]);
+    return { url, loading, error };
+};
+exports.useFileDownloadUrl = useFileDownloadUrl;

package/src/ui/hooks/useFileFiltering.d.ts

@@ -0,0 +1,28 @@
+import type { FileMetadata } from '@oxyhq/core';
+export type ViewMode = 'all' | 'photos' | 'videos' | 'documents' | 'audio';
+export type SortBy = 'date' | 'size' | 'name' | 'type';
+export type SortOrder = 'asc' | 'desc';
+interface UseFileFilteringOptions {
+    files: FileMetadata[];
+    initialViewMode?: ViewMode;
+    initialSortBy?: SortBy;
+    initialSortOrder?: SortOrder;
+}
+interface UseFileFilteringReturn {
+    filteredFiles: FileMetadata[];
+    viewMode: ViewMode;
+    setViewMode: (mode: ViewMode) => void;
+    searchQuery: string;
+    setSearchQuery: (query: string) => void;
+    sortBy: SortBy;
+    setSortBy: (sort: SortBy) => void;
+    sortOrder: SortOrder;
+    setSortOrder: (order: SortOrder) => void;
+    toggleSortOrder: () => void;
+}
+/**
+ * Hook for file filtering, sorting, and search functionality
+ * Extracts common file management logic for reuse across components
+ */
+export declare function useFileFiltering({ files, initialViewMode, initialSortBy, initialSortOrder, }: UseFileFilteringOptions): UseFileFilteringReturn;
+export {};

package/src/ui/hooks/useFileFiltering.js

@@ -0,0 +1,80 @@
+"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?.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/src/ui/hooks/useFollow.d.ts

@@ -0,0 +1,92 @@
+import type { OxyServices } from '@oxyhq/core';
+/**
+ * useFollow — Hook for follow state management.
+ *
+ * Performance fixes:
+ * 1. Uses granular Zustand selectors instead of subscribing to the entire store.
+ *    The old `useFollowStore()` caused every component using this hook to re-render
+ *    on ANY store change (any user's follow status, loading state, error, or count).
+ * 2. Callbacks depend on primitive values (userId, isFollowing) not object references,
+ *    so they remain stable across renders.
+ * 3. Store action methods are accessed via getState() in callbacks to avoid
+ *    subscribing to the action functions themselves (they never change but including
+ *    them in selectors would cause unnecessary selector recalculations).
+ */
+export declare const useFollow: (userId?: string | string[]) => {
+    isFollowing: boolean;
+    isLoading: boolean;
+    error: string | null;
+    toggleFollow: () => Promise<void>;
+    setFollowStatus: (following: boolean) => void;
+    fetchStatus: () => Promise<void>;
+    clearError: () => void;
+    followerCount: number | null;
+    followingCount: number | null;
+    isLoadingCounts: boolean;
+    fetchUserCounts: () => Promise<void>;
+    setFollowerCount: (count: number) => void;
+    setFollowingCount: (count: number) => void;
+    followData?: undefined;
+    toggleFollowForUser?: undefined;
+    setFollowStatusForUser?: undefined;
+    fetchStatusForUser?: undefined;
+    fetchAllStatuses?: undefined;
+    clearErrorForUser?: undefined;
+    isAnyLoading?: undefined;
+    hasAnyError?: undefined;
+    allFollowing?: undefined;
+    allNotFollowing?: undefined;
+} | {
+    followData: Record<string, {
+        isFollowing: boolean;
+        isLoading: boolean;
+        error: string | null;
+    }>;
+    toggleFollowForUser: (targetUserId: string) => Promise<void>;
+    setFollowStatusForUser: (targetUserId: string, following: boolean) => void;
+    fetchStatusForUser: (targetUserId: string) => Promise<void>;
+    fetchAllStatuses: () => Promise<void>;
+    clearErrorForUser: (targetUserId: string) => void;
+    isAnyLoading: boolean;
+    hasAnyError: boolean;
+    allFollowing: boolean;
+    allNotFollowing: boolean;
+    isFollowing?: undefined;
+    isLoading?: undefined;
+    error?: undefined;
+    toggleFollow?: undefined;
+    setFollowStatus?: undefined;
+    fetchStatus?: undefined;
+    clearError?: undefined;
+    followerCount?: undefined;
+    followingCount?: undefined;
+    isLoadingCounts?: undefined;
+    fetchUserCounts?: undefined;
+    setFollowerCount?: undefined;
+    setFollowingCount?: undefined;
+};
+/**
+ * useFollowForButton — Lightweight follow hook for FollowButton in list contexts.
+ *
+ * Unlike useFollow, this hook:
+ * - Accepts oxyServices directly (no useOxy() context subscription)
+ * - Only subscribes to the specific user's follow and loading state
+ * - Returns only what FollowButton needs (no counts, no multi-user)
+ */
+export declare const useFollowForButton: (userId: string, oxyServices: OxyServices) => {
+    isFollowing: boolean;
+    isLoading: boolean;
+    error: string | null;
+    toggleFollow: () => Promise<void>;
+    fetchStatus: () => Promise<void>;
+    setFollowStatus: (following: boolean) => void;
+    clearError: () => void;
+};
+export declare const useFollowerCounts: (userId: string) => {
+    followerCount: number;
+    followingCount: number;
+    isLoadingCounts: boolean;
+    fetchUserCounts: () => Promise<void>;
+    setFollowerCount: (count: number) => void;
+    setFollowingCount: (count: number) => void;
+};

package/src/ui/hooks/useFollow.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFollowerCounts = exports.useFollowForButton = exports.useFollow = void 0;
+const react_1 = require("react");
+const followStore_1 = require("../stores/followStore");
+const OxyContext_1 = require("../context/OxyContext");
+const shallow_1 = require("zustand/react/shallow");
+/**
+ * useFollow — Hook for follow state management.
+ *
+ * Performance fixes:
+ * 1. Uses granular Zustand selectors instead of subscribing to the entire store.
+ *    The old `useFollowStore()` caused every component using this hook to re-render
+ *    on ANY store change (any user's follow status, loading state, error, or count).
+ * 2. Callbacks depend on primitive values (userId, isFollowing) not object references,
+ *    so they remain stable across renders.
+ * 3. Store action methods are accessed via getState() in callbacks to avoid
+ *    subscribing to the action functions themselves (they never change but including
+ *    them in selectors would cause unnecessary selector recalculations).
+ */
+const useFollow = (userId) => {
+    const { oxyServices } = (0, OxyContext_1.useOxy)();
+    const userIds = (0, react_1.useMemo)(() => (Array.isArray(userId) ? userId : userId ? [userId] : []), [userId]);
+    const isSingleUser = typeof userId === 'string';
+    // Granular Zustand selectors — only re-render when THIS user's data changes
+    const isFollowing = (0, followStore_1.useFollowStore)((0, react_1.useCallback)((s) => (isSingleUser && userId ? s.followingUsers[userId] ?? false : false), [isSingleUser, userId]));
+    const isLoading = (0, followStore_1.useFollowStore)((0, react_1.useCallback)((s) => (isSingleUser && userId ? s.loadingUsers[userId] ?? false : false), [isSingleUser, userId]));
+    const error = (0, followStore_1.useFollowStore)((0, react_1.useCallback)((s) => (isSingleUser && userId ? s.errors[userId] ?? null : null), [isSingleUser, userId]));
+    const followerCount = (0, followStore_1.useFollowStore)((0, react_1.useCallback)((s) => (isSingleUser && userId ? s.followerCounts[userId] ?? null : null), [isSingleUser, userId]));
+    const followingCount = (0, followStore_1.useFollowStore)((0, react_1.useCallback)((s) => (isSingleUser && userId ? s.followingCounts[userId] ?? null : null), [isSingleUser, userId]));
+    const isLoadingCounts = (0, followStore_1.useFollowStore)((0, react_1.useCallback)((s) => (isSingleUser && userId ? s.loadingCounts[userId] ?? false : false), [isSingleUser, userId]));
+    // For multi-user mode, use shallow comparison to avoid re-renders when unrelated users change
+    const followData = (0, followStore_1.useFollowStore)((0, shallow_1.useShallow)((s) => {
+        if (isSingleUser)
+            return {};
+        const data = {};
+        for (const uid of userIds) {
+            data[uid] = {
+                isFollowing: s.followingUsers[uid] ?? false,
+                isLoading: s.loadingUsers[uid] ?? false,
+                error: s.errors[uid] ?? null,
+            };
+        }
+        return data;
+    }));
+    // Multi-user aggregate selectors
+    const multiUserLoadingState = (0, followStore_1.useFollowStore)((0, shallow_1.useShallow)((s) => {
+        if (isSingleUser)
+            return { isAnyLoading: false, hasAnyError: false, allFollowing: true, allNotFollowing: true };
+        return {
+            isAnyLoading: userIds.some(uid => s.loadingUsers[uid]),
+            hasAnyError: userIds.some(uid => !!s.errors[uid]),
+            allFollowing: userIds.every(uid => s.followingUsers[uid]),
+            allNotFollowing: userIds.every(uid => !s.followingUsers[uid]),
+        };
+    }));
+    // Stable callbacks that depend on primitives, not object references.
+    // Store actions are accessed via getState() to avoid subscribing to them.
+    const toggleFollow = (0, react_1.useCallback)(async () => {
+        if (!isSingleUser || !userId)
+            throw new Error('toggleFollow is only available for single user mode');
+        const currentlyFollowing = followStore_1.useFollowStore.getState().followingUsers[userId] ?? false;
+        await followStore_1.useFollowStore.getState().toggleFollowUser(userId, oxyServices, currentlyFollowing);
+    }, [isSingleUser, userId, oxyServices]);
+    const setFollowStatus = (0, react_1.useCallback)((following) => {
+        if (!isSingleUser || !userId)
+            throw new Error('setFollowStatus is only available for single user mode');
+        followStore_1.useFollowStore.getState().setFollowingStatus(userId, following);
+    }, [isSingleUser, userId]);
+    const fetchStatus = (0, react_1.useCallback)(async () => {
+        if (!isSingleUser || !userId)
+            throw new Error('fetchStatus is only available for single user mode');
+        await followStore_1.useFollowStore.getState().fetchFollowStatus(userId, oxyServices);
+    }, [isSingleUser, userId, oxyServices]);
+    const clearError = (0, react_1.useCallback)(() => {
+        if (!isSingleUser || !userId)
+            throw new Error('clearError is only available for single user mode');
+        followStore_1.useFollowStore.getState().clearFollowError(userId);
+    }, [isSingleUser, userId]);
+    const fetchUserCounts = (0, react_1.useCallback)(async () => {
+        if (!isSingleUser || !userId)
+            throw new Error('fetchUserCounts is only available for single user mode');
+        await followStore_1.useFollowStore.getState().fetchUserCounts(userId, oxyServices);
+    }, [isSingleUser, userId, oxyServices]);
+    const setFollowerCount = (0, react_1.useCallback)((count) => {
+        if (!isSingleUser || !userId)
+            throw new Error('setFollowerCount is only available for single user mode');
+        followStore_1.useFollowStore.getState().setFollowerCount(userId, count);
+    }, [isSingleUser, userId]);
+    const setFollowingCount = (0, react_1.useCallback)((count) => {
+        if (!isSingleUser || !userId)
+            throw new Error('setFollowingCount is only available for single user mode');
+        followStore_1.useFollowStore.getState().setFollowingCount(userId, count);
+    }, [isSingleUser, userId]);
+    // Auto-fetch counts when hook is used for a single user and counts are missing.
+    (0, react_1.useEffect)(() => {
+        if (!isSingleUser || !userId)
+            return;
+        if ((followerCount === null || followingCount === null) && !isLoadingCounts) {
+            fetchUserCounts().catch((err) => console.warn('useFollow: fetchUserCounts failed', err));
+        }
+    }, [isSingleUser, userId, followerCount, followingCount, isLoadingCounts, fetchUserCounts]);
+    // Multi-user callbacks
+    const toggleFollowForUser = (0, react_1.useCallback)(async (targetUserId) => {
+        const currentState = followStore_1.useFollowStore.getState().followingUsers[targetUserId] ?? false;
+        await followStore_1.useFollowStore.getState().toggleFollowUser(targetUserId, oxyServices, currentState);
+    }, [oxyServices]);
+    const setFollowStatusForUser = (0, react_1.useCallback)((targetUserId, following) => {
+        followStore_1.useFollowStore.getState().setFollowingStatus(targetUserId, following);
+    }, []);
+    const fetchStatusForUser = (0, react_1.useCallback)(async (targetUserId) => {
+        await followStore_1.useFollowStore.getState().fetchFollowStatus(targetUserId, oxyServices);
+    }, [oxyServices]);
+    const fetchAllStatuses = (0, react_1.useCallback)(async () => {
+        const store = followStore_1.useFollowStore.getState();
+        await Promise.all(userIds.map(uid => store.fetchFollowStatus(uid, oxyServices)));
+    }, [userIds, oxyServices]);
+    const clearErrorForUser = (0, react_1.useCallback)((targetUserId) => {
+        followStore_1.useFollowStore.getState().clearFollowError(targetUserId);
+    }, []);
+    const updateCountsFromFollowAction = (0, react_1.useCallback)((targetUserId, action, counts) => {
+        const currentUserId = oxyServices.getCurrentUserId() || undefined;
+        followStore_1.useFollowStore.getState().updateCountsFromFollowAction(targetUserId, action, counts, currentUserId);
+    }, [oxyServices]);
+    if (isSingleUser && userId) {
+        return {
+            isFollowing,
+            isLoading,
+            error,
+            toggleFollow,
+            setFollowStatus,
+            fetchStatus,
+            clearError,
+            followerCount,
+            followingCount,
+            isLoadingCounts,
+            fetchUserCounts,
+            setFollowerCount,
+            setFollowingCount,
+        };
+    }
+    return {
+        followData,
+        toggleFollowForUser,
+        setFollowStatusForUser,
+        fetchStatusForUser,
+        fetchAllStatuses,
+        clearErrorForUser,
+        isAnyLoading: multiUserLoadingState.isAnyLoading,
+        hasAnyError: multiUserLoadingState.hasAnyError,
+        allFollowing: multiUserLoadingState.allFollowing,
+        allNotFollowing: multiUserLoadingState.allNotFollowing,
+    };
+};
+exports.useFollow = useFollow;
+/**
+ * useFollowForButton — Lightweight follow hook for FollowButton in list contexts.
+ *
+ * Unlike useFollow, this hook:
+ * - Accepts oxyServices directly (no useOxy() context subscription)
+ * - Only subscribes to the specific user's follow and loading state
+ * - Returns only what FollowButton needs (no counts, no multi-user)
+ */
+const useFollowForButton = (userId, oxyServices) => {
+    const isFollowing = (0, followStore_1.useFollowStore)((0, react_1.useCallback)((s) => s.followingUsers[userId] ?? false, [userId]));
+    const isLoading = (0, followStore_1.useFollowStore)((0, react_1.useCallback)((s) => s.loadingUsers[userId] ?? false, [userId]));
+    const error = (0, followStore_1.useFollowStore)((0, react_1.useCallback)((s) => s.errors[userId] ?? null, [userId]));
+    const toggleFollow = (0, react_1.useCallback)(async () => {
+        const currentlyFollowing = followStore_1.useFollowStore.getState().followingUsers[userId] ?? false;
+        await followStore_1.useFollowStore.getState().toggleFollowUser(userId, oxyServices, currentlyFollowing);
+    }, [userId, oxyServices]);
+    const fetchStatus = (0, react_1.useCallback)(async () => {
+        await followStore_1.useFollowStore.getState().fetchFollowStatus(userId, oxyServices);
+    }, [userId, oxyServices]);
+    const setFollowStatus = (0, react_1.useCallback)((following) => {
+        followStore_1.useFollowStore.getState().setFollowingStatus(userId, following);
+    }, [userId]);
+    const clearError = (0, react_1.useCallback)(() => {
+        followStore_1.useFollowStore.getState().clearFollowError(userId);
+    }, [userId]);
+    return {
+        isFollowing,
+        isLoading,
+        error,
+        toggleFollow,
+        fetchStatus,
+        setFollowStatus,
+        clearError,
+    };
+};
+exports.useFollowForButton = useFollowForButton;
+// Convenience hook for just follower counts
+const useFollowerCounts = (userId) => {
+    const { oxyServices } = (0, OxyContext_1.useOxy)();
+    const followerCount = (0, followStore_1.useFollowStore)((0, react_1.useCallback)((s) => s.followerCounts[userId] ?? null, [userId]));
+    const followingCount = (0, followStore_1.useFollowStore)((0, react_1.useCallback)((s) => s.followingCounts[userId] ?? null, [userId]));
+    const isLoadingCounts = (0, followStore_1.useFollowStore)((0, react_1.useCallback)((s) => s.loadingCounts[userId] ?? false, [userId]));
+    const fetchUserCounts = (0, react_1.useCallback)(async () => {
+        await followStore_1.useFollowStore.getState().fetchUserCounts(userId, oxyServices);
+    }, [userId, oxyServices]);
+    const setFollowerCount = (0, react_1.useCallback)((count) => {
+        followStore_1.useFollowStore.getState().setFollowerCount(userId, count);
+    }, [userId]);
+    const setFollowingCount = (0, react_1.useCallback)((count) => {
+        followStore_1.useFollowStore.getState().setFollowingCount(userId, count);
+    }, [userId]);
+    return {
+        followerCount,
+        followingCount,
+        isLoadingCounts,
+        fetchUserCounts,
+        setFollowerCount,
+        setFollowingCount,
+    };
+};
+exports.useFollowerCounts = useFollowerCounts;

package/src/ui/hooks/useFollow.types.d.ts

@@ -0,0 +1,32 @@
+export type SingleFollowResult = {
+    isFollowing: boolean;
+    isLoading: boolean;
+    error: string | null;
+    toggleFollow: () => Promise<void>;
+    setFollowStatus: (following: boolean) => void;
+    fetchStatus: () => Promise<void>;
+    clearError: () => void;
+    followerCount: number | null;
+    followingCount: number | null;
+    isLoadingCounts: boolean;
+    fetchUserCounts: () => Promise<void>;
+    setFollowerCount: (count: number) => void;
+    setFollowingCount: (count: number) => void;
+};
+export type MultiFollowResult = {
+    followData: Record<string, {
+        isFollowing: boolean;
+        isLoading: boolean;
+        error: string | null;
+    }>;
+    toggleFollowForUser: (userId: string) => Promise<void>;
+    setFollowStatusForUser: (userId: string, following: boolean) => void;
+    fetchStatusForUser: (userId: string) => Promise<void>;
+    fetchAllStatuses: () => Promise<void>;
+    clearErrorForUser: (userId: string) => void;
+    isAnyLoading: boolean;
+    hasAnyError: boolean;
+    allFollowing: boolean;
+    allNotFollowing: boolean;
+};
+export type UseFollowHook = (userId?: string | string[]) => SingleFollowResult | MultiFollowResult;

package/src/ui/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/src/ui/hooks/useI18n.d.ts

@@ -0,0 +1,4 @@
+export declare function useI18n(): {
+    t: (key: string, vars?: Record<string, string | number>) => any;
+    locale: string;
+};

package/src/ui/hooks/useI18n.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useI18n = useI18n;
+const react_1 = require("react");
+const OxyContext_1 = require("../context/OxyContext");
+const core_1 = require("@oxyhq/core");
+function useI18n() {
+    const { currentLanguage } = (0, OxyContext_1.useOxy)();
+    const t = (0, react_1.useMemo)(() => {
+        return (key, vars) => (0, core_1.translate)(currentLanguage, key, vars);
+    }, [currentLanguage]);
+    return { t, locale: currentLanguage };
+}