@yogiswara/honcho-editor-ui 2.7.13 → 2.7.14

package/dist/hooks/useGallerySwipe.d.ts

@@ -1,36 +0,0 @@
-import { Controller } from "./editor/type";
-import { Gallery } from "./editor/type";
-/**
- * Return type for the useGallerySwipe hook
- * Provides image navigation functionality with pagination support
- */
-interface UseGallerySwipeReturn {
-    /** Current image data object containing all image information */
-    currentImageData: Gallery | null;
-    /** Whether next image navigation is available (considers pagination) */
-    isNextAvailable: boolean;
-    /** Whether previous image navigation is available */
-    isPrevAvailable: boolean;
-    /** Function to navigate to the next image (async due to potential API calls) */
-    onSwipeNext: () => Promise<void>;
-    /** Function to navigate to the previous image (async due to potential API calls) */
-    onSwipePrev: () => Promise<void>;
-    /** Loading state during image transitions and API calls */
-    isLoading: boolean;
-    /** Error message if any operation fails */
-    error: string | null;
-}
-/**
- * Custom hook for handling image gallery navigation with automatic pagination
- *
- * This hook manages image swipe/navigation functionality across a paginated gallery.
- * It handles the complexity of finding images across multiple pages and loading
- * additional pages as needed during navigation.
- *
- * @param firebaseUid - User's Firebase UID (can be null during initialization)
- * @param initImageId - Initial image ID to start with (can be null during initialization)
- * @param controller - Controller instance for API calls (can be null during initialization)
- * @returns Object containing current image data and navigation functions
- */
-export declare function useGallerySwipe(firebaseUid: string | null, initImageId: string | null, controller: Controller | null): UseGallerySwipeReturn;
-export {};

package/dist/hooks/useGallerySwipe.js

@@ -1,344 +0,0 @@
-import { useState, useEffect, useCallback, useRef } from "react";
-/**
- * Custom hook for handling image gallery navigation with automatic pagination
- *
- * This hook manages image swipe/navigation functionality across a paginated gallery.
- * It handles the complexity of finding images across multiple pages and loading
- * additional pages as needed during navigation.
- *
- * @param firebaseUid - User's Firebase UID (can be null during initialization)
- * @param initImageId - Initial image ID to start with (can be null during initialization)
- * @param controller - Controller instance for API calls (can be null during initialization)
- * @returns Object containing current image data and navigation functions
- */
-export function useGallerySwipe(firebaseUid, initImageId, controller) {
-    // Core state for current image and navigation
-    const [currentImageId, setCurrentImageId] = useState(initImageId);
-    const [currentImageData, setCurrentImageData] = useState(null);
-    const [currentEventId, setCurrentEventId] = useState(null);
-    // Pagination and image list state
-    const [currentImageList, setCurrentImageList] = useState([]);
-    const [currentPage, setCurrentPage] = useState(1);
-    const [hasNextPage, setHasNextPage] = useState(false);
-    // UI state management
-    const [isLoading, setIsLoading] = useState(false);
-    const [error, setError] = useState(null);
-    const [isInitialized, setIsInitialized] = useState(false);
-    // Refs to track parameter changes and avoid unnecessary re-initialization
-    // This prevents the hook from re-initializing when the same values are passed
-    const prevFirebaseUid = useRef(null);
-    const prevInitImageId = useRef(null);
-    /**
-     * Get the index of the current image in the loaded image list
-     * Returns -1 if the current image is not found in the list
-     */
-    const getCurrentImageIndex = useCallback(() => {
-        if (!currentImageId || currentImageList.length === 0)
-            return -1;
-        return currentImageList.findIndex(img => img.id === currentImageId);
-    }, [currentImageId, currentImageList]);
-    /**
-     * Fetch image pages sequentially until the target image is found
-     * This is necessary because we don't know which page contains the initial image
-     *
-     * @param imageId - The target image ID to find
-     * @param eventId - The event ID to search within
-     * @returns Array of all gallery images up to and including the page containing the target image
-     */
-    const getImageListUntilFound = useCallback(async (imageId, eventId) => {
-        let page = 1;
-        let allImages = [];
-        let isFound = false;
-        // Search through pages until we find the target image or reach safety limit
-        while (!isFound && page <= 100) { // Safety limit to prevent infinite loop
-            try {
-                const response = await controller.getImageList(firebaseUid, eventId, page);
-                if (response.gallery && response.gallery.length > 0) {
-                    // Accumulate all images from previous pages
-                    allImages = [...allImages, ...response.gallery];
-                    // Check if target image is found in current page
-                    isFound = response.gallery.some(img => img.id === imageId);
-                    if (isFound) {
-                        // Update pagination state when target is found
-                        setCurrentPage(page);
-                        setHasNextPage(response.next_page !== 0 && response.next_page > response.current_page);
-                        break;
-                    }
-                    // If no next page exists, stop searching
-                    if (response.next_page === 0 || response.next_page <= response.current_page) {
-                        break;
-                    }
-                    page++;
-                }
-                else {
-                    // Empty response, stop searching
-                    break;
-                }
-            }
-            catch (err) {
-                console.error(`Error fetching page ${page}:`, err);
-                break;
-            }
-        }
-        return allImages;
-    }, [controller, firebaseUid]);
-    /**
-     * Load the next page of images when user reaches the end of current list
-     * This enables seamless navigation across page boundaries
-     *
-     * @returns Array of new images from the next page, or empty array if no more pages
-     */
-    const loadNextPage = useCallback(async () => {
-        // Check prerequisites before attempting to load next page
-        if (!hasNextPage || !currentEventId || !controller || !firebaseUid) {
-            return [];
-        }
-        try {
-            const nextPageNum = currentPage + 1;
-            const response = await controller.getImageList(firebaseUid, currentEventId, nextPageNum);
-            if (response.gallery && response.gallery.length > 0) {
-                // Update pagination state with new page information
-                setCurrentPage(nextPageNum);
-                setHasNextPage(response.next_page !== 0 && response.next_page > response.current_page);
-                return response.gallery;
-            }
-        }
-        catch (err) {
-            console.error('Error loading next page:', err);
-        }
-        return [];
-    }, [hasNextPage, currentEventId, controller, firebaseUid, currentPage]);
-    /**
-     * Initialize or re-initialize the gallery when parameters change
-     * This function:
-     * 1. Fetches initial image data
-     * 2. Discovers the event ID from the image
-     * 3. Loads all image pages until the initial image is found
-     * 4. Sets up pagination state
-     *
-     * Only re-initializes when parameters actually change to avoid unnecessary API calls
-     */
-    const initializeGallery = useCallback(async () => {
-        // Early return if required parameters are missing
-        if (!firebaseUid || !initImageId || !controller) {
-            setCurrentImageData(null);
-            setCurrentImageList([]);
-            setIsInitialized(false);
-            return;
-        }
-        // Check if re-initialization is needed by comparing with previous values
-        const needsReinit = prevFirebaseUid.current !== firebaseUid ||
-            prevInitImageId.current !== initImageId ||
-            !isInitialized;
-        if (!needsReinit)
-            return;
-        setIsLoading(true);
-        setError(null);
-        try {
-            // Step 1: Get initial image data to discover event ID
-            const gallery = await controller.onGetImage(firebaseUid, initImageId);
-            if (!gallery) {
-                throw new Error('Failed to fetch initial image data');
-            }
-            // Step 2: Set up initial state with discovered data
-            setCurrentImageData(gallery);
-            setCurrentImageId(initImageId);
-            setCurrentEventId(gallery.event_id);
-            // Step 3: Get complete image list by searching through pages
-            // This ensures we have navigation context for the current image
-            const allImages = await getImageListUntilFound(initImageId, gallery.event_id);
-            console.log("Print all images Id: ", allImages.map(image => image.id).join(', '));
-            setCurrentImageList(allImages);
-            // Step 4: Update tracking refs to prevent unnecessary re-initialization
-            prevFirebaseUid.current = firebaseUid;
-            prevInitImageId.current = initImageId;
-            setIsInitialized(true);
-        }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : 'Unknown error occurred';
-            setError(errorMessage);
-            console.error('Error initializing gallery:', err);
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [firebaseUid, initImageId, controller, getImageListUntilFound, isInitialized]);
-    /**
-     * Navigate to the next image in the gallery
-     * Handles two scenarios:
-     * 1. Next image exists in current loaded list - navigate directly
-     * 2. At end of current list - load next page and navigate to first image of new page
-     *
-     * @returns Promise that resolves when navigation is complete
-     */
-    const onSwipeNext = useCallback(async () => {
-        // Prevent action if no current image or already loading
-        if (!currentImageId || isLoading)
-            return;
-        setIsLoading(true);
-        setError(null);
-        try {
-            // Debug logging
-            console.log("=== SWIPE NEXT DEBUG ===");
-            console.log("currentImageId:", currentImageId);
-            console.log("currentImageList length:", currentImageList.length);
-            console.log("currentImageList IDs:", currentImageList.map(img => img.id).join(", "));
-            // Calculate current index
-            const currentIndex = getCurrentImageIndex();
-            console.log("Current index: ", currentIndex);
-            if (currentIndex === -1) {
-                throw new Error('Current image not found in list');
-            }
-            // Scenario 1: At the last image of current list
-            if (currentIndex === currentImageList.length - 1) {
-                console.log("[SCENARIO 1] if last image: " + currentImageList.length);
-                // Try to load next page for more images
-                const newImages = await loadNextPage();
-                if (newImages.length > 0) {
-                    // Extend current list with new images
-                    const updatedList = [...currentImageList, ...newImages];
-                    setCurrentImageList(updatedList);
-                    // Navigate to first image of the new page
-                    const nextImage = newImages[0];
-                    console.log("Setting currentImageId to:", nextImage.id);
-                    setCurrentImageId(nextImage.id);
-                    // Fetch complete data for the new current image
-                    const nextImageData = await controller.onGetImage(firebaseUid, nextImage.id);
-                    if (nextImageData) {
-                        setCurrentImageData(nextImageData);
-                    }
-                }
-                else {
-                    // No more pages available - end of gallery reached
-                    setError('No more images available');
-                }
-            }
-            else {
-                // Scenario 2: Navigate to next image in current list
-                const nextImage = currentImageList[currentIndex + 1];
-                console.log("[SCENARIO 2] Navigating to next image:", nextImage.id);
-                console.log("Setting currentImageId from", currentImageId, "to", nextImage.id);
-                setCurrentImageId(nextImage.id);
-                // Fetch complete data for the next image
-                const nextImageData = await controller.onGetImage(firebaseUid, nextImage.id);
-                if (nextImageData) {
-                    setCurrentImageData(nextImageData);
-                }
-            }
-        }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : 'Error moving to next image';
-            setError(errorMessage);
-            console.error('Error in onSwipeNext:', err);
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [currentImageId, isLoading, getCurrentImageIndex, currentImageList, loadNextPage, controller, firebaseUid]);
-    /**
-     * Navigate to the previous image in the gallery
-     * Only works within the currently loaded image list
-     * (Previous pages are not loaded on-demand for backward navigation)
-     *
-     * @returns Promise that resolves when navigation is complete
-     */
-    const onSwipePrev = useCallback(async () => {
-        // Prevent action if no current image or already loading
-        if (!currentImageId || isLoading)
-            return;
-        setIsLoading(true);
-        setError(null);
-        try {
-            // Calculate current index
-            const currentIndex = getCurrentImageIndex();
-            if (currentIndex === -1) {
-                throw new Error('Current image not found in list');
-            }
-            if (currentIndex > 0) {
-                // Navigate to previous image in the current list
-                const prevImage = currentImageList[currentIndex - 1];
-                setCurrentImageId(prevImage.id);
-                // Fetch complete data for the previous image
-                const prevImageData = await controller.onGetImage(firebaseUid, prevImage.id);
-                if (prevImageData) {
-                    setCurrentImageData(prevImageData);
-                }
-            }
-            else {
-                // Already at the first image of loaded list
-                setError('Already at the first image');
-            }
-        }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : 'Error moving to previous image';
-            setError(errorMessage);
-            console.error('Error in onSwipePrev:', err);
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [currentImageId, isLoading, getCurrentImageIndex, currentImageList, controller, firebaseUid]);
-    /**
-     * Calculate if next image navigation is available
-     * Returns true if:
-     * 1. There's a next image in the current loaded list, OR
-     * 2. We're at the end of current list but more pages are available
-     *
-     * @returns Boolean indicating if next navigation is possible
-     */
-    const isNextAvailable = useCallback(() => {
-        if (isLoading || !currentImageId)
-            return false;
-        // Calculate current index
-        const currentIndex = getCurrentImageIndex();
-        if (currentIndex === -1)
-            return false;
-        // If we're not at the last image, next is definitely available
-        if (currentIndex < currentImageList.length - 1)
-            return true;
-        // If we're at the last image but there are more pages, next is still available
-        return hasNextPage;
-    }, [isLoading, getCurrentImageIndex, currentImageList.length, hasNextPage]);
-    /**
-     * Calculate if previous image navigation is available
-     * Returns true if there's a previous image in the currently loaded list
-     *
-     * @returns Boolean indicating if previous navigation is possible
-     */
-    const isPrevAvailable = useCallback(() => {
-        if (isLoading || !currentImageId)
-            return false;
-        // Calculate current index
-        const currentIndex = getCurrentImageIndex();
-        return currentIndex > 0;
-    }, [isLoading, getCurrentImageIndex]);
-    // Initialize when dependencies change
-    useEffect(() => {
-        initializeGallery();
-    }, [initializeGallery]);
-    // Update currentImageId when initImageId changes from external source
-    // This allows the hook to respond to external changes to the initial image ID
-    // but should not interfere with internal navigation
-    useEffect(() => {
-        // Only update if initImageId actually changed and we're not currently loading
-        // (loading indicates we're in the middle of navigation)
-        if (initImageId && initImageId !== currentImageId && !isLoading) {
-            // Additional check: only update if this is truly an external change
-            // If prevInitImageId is different from initImageId, it's an external change
-            if (prevInitImageId.current !== initImageId) {
-                console.log("External initImageId change detected, updating currentImageId");
-                setCurrentImageId(initImageId);
-            }
-        }
-    }, [initImageId]);
-    // Return all the functionality and state that components need
-    return {
-        currentImageData,
-        isNextAvailable: isNextAvailable(),
-        isPrevAvailable: isPrevAvailable(),
-        onSwipeNext,
-        onSwipePrev,
-        isLoading,
-        error
-    };
-}

package/dist/hooks/usePaging.d.ts

@@ -1,89 +0,0 @@
-import { Gallery } from './editor/type';
-import { Controller } from "./editor/type";
-/**
- * Configuration options for the paging hook
- */
-export interface PagingOptions {
-    /** Enable development warnings for debugging */
-    devWarnings?: boolean;
-    /** Auto-load first page on hook initialization */
-    autoLoad?: boolean;
-    /** Reset pagination when dependencies change */
-    autoReset?: boolean;
-}
-/**
- * Information about the current paging state
- */
-export interface PagingInfo {
-    /** Whether images are currently being loaded */
-    isLoading: boolean;
-    /** Whether more pages are being loaded */
-    isLoadingMore: boolean;
-    /** Error message if any operation failed */
-    error: string | null;
-    /** Current page number */
-    currentPage: number;
-    /** Whether there are more pages to load */
-    hasMore: boolean;
-    /** Total number of images loaded */
-    totalImages: number;
-    /** Whether the hook has been initialized */
-    isInitialized: boolean;
-}
-/**
- * Actions available for paging management
- */
-export interface PagingActions {
-    /** Load more images (next page) - only one instance can run at a time */
-    loadMore: () => Promise<void>;
-    /** Refresh/reload from first page */
-    refresh: () => Promise<void>;
-    /** Reset pagination state */
-    reset: () => void;
-}
-/**
- * Return type for the usePaging hook
- */
-export interface UsePagingReturn {
-    /** Current list of images */
-    images: Gallery[];
-    /** Information about paging state */
-    info: PagingInfo;
-    /** Available paging actions */
-    actions: PagingActions;
-}
-/**
- * Hook for managing paginated image loading with ControllerBulk.
- *
- * **Key Features:**
- * - **Paginated Loading**: Handles page-by-page image loading
- * - **State Management**: Maintains image list and pagination state
- * - **Load More**: Seamlessly loads and appends next pages
- * - **Mutation**: Update specific images without full reload
- * - **Error Handling**: Provides error states for failed operations
- * - **Auto-loading**: Optional automatic first page loading
- *
- * **Typical Usage:**
- * ```typescript
- * const { images, info, actions } = usePaging(controller, firebaseUid, eventId, {
- *   autoLoad: true,
- *   autoReset: true
- * });
- *
- * // Load more images
- * await actions.loadMore();
- *
- * // Refresh from beginning
- * await actions.refresh();
- *
- * // Update specific image
- * actions.mutateImage(imageId, (img) => ({ ...img, isSelected: true }));
- * ```
- *
- * @param controller - Backend controller for API communication
- * @param firebaseUid - User identifier for backend operations
- * @param eventId - Event identifier for image list
- * @param options - Configuration options
- * @returns Object with images, info, and actions
- */
-export declare function usePaging(controller: Controller | null, firebaseUid: string, eventId: string, options?: PagingOptions): UsePagingReturn;

package/dist/hooks/usePaging.js

@@ -1,211 +0,0 @@
-import { useState, useCallback, useEffect, useRef, useMemo } from 'react';
-/**
- * Hook for managing paginated image loading with ControllerBulk.
- *
- * **Key Features:**
- * - **Paginated Loading**: Handles page-by-page image loading
- * - **State Management**: Maintains image list and pagination state
- * - **Load More**: Seamlessly loads and appends next pages
- * - **Mutation**: Update specific images without full reload
- * - **Error Handling**: Provides error states for failed operations
- * - **Auto-loading**: Optional automatic first page loading
- *
- * **Typical Usage:**
- * ```typescript
- * const { images, info, actions } = usePaging(controller, firebaseUid, eventId, {
- *   autoLoad: true,
- *   autoReset: true
- * });
- *
- * // Load more images
- * await actions.loadMore();
- *
- * // Refresh from beginning
- * await actions.refresh();
- *
- * // Update specific image
- * actions.mutateImage(imageId, (img) => ({ ...img, isSelected: true }));
- * ```
- *
- * @param controller - Backend controller for API communication
- * @param firebaseUid - User identifier for backend operations
- * @param eventId - Event identifier for image list
- * @param options - Configuration options
- * @returns Object with images, info, and actions
- */
-export function usePaging(controller, firebaseUid, eventId, options = {}) {
-    // Memoize options to prevent re-renders when object is recreated with same values
-    const memoizedOptions = useMemo(() => ({
-        devWarnings: options.devWarnings ?? false,
-        autoLoad: options.autoLoad ?? false,
-        autoReset: options.autoReset ?? true
-    }), [options.devWarnings, options.autoLoad, options.autoReset]);
-    // Core state
-    const [images, setImages] = useState([]);
-    const [isLoading, setIsLoading] = useState(false);
-    const [isLoadingMore, setIsLoadingMore] = useState(false);
-    const [error, setError] = useState(null);
-    const [currentPage, setCurrentPage] = useState(1);
-    const [hasMore, setHasMore] = useState(true);
-    const [isInitialized, setIsInitialized] = useState(false);
-    // Track if loadMore is currently running to prevent spam
-    const isLoadMoreRunningRef = useRef(false);
-    // Track dependencies with stable refs
-    const controllerRef = useRef(controller);
-    const firebaseUidRef = useRef(firebaseUid);
-    const eventIdRef = useRef(eventId);
-    // Only update refs when values actually change
-    if (controllerRef.current !== controller) {
-        controllerRef.current = controller;
-    }
-    if (firebaseUidRef.current !== firebaseUid) {
-        firebaseUidRef.current = firebaseUid;
-    }
-    if (eventIdRef.current !== eventId) {
-        eventIdRef.current = eventId;
-    }
-    // Helper function to log debug messages
-    const debugLog = useCallback((message, data) => {
-        if (memoizedOptions.devWarnings) {
-            console.log(`[usePaging] ${message}`, data || '');
-        }
-    }, [memoizedOptions.devWarnings]);
-    // Helper function to handle errors
-    const handleError = useCallback((operation, error) => {
-        const errorMessage = `Failed to ${operation}: ${error instanceof Error ? error.message : String(error)}`;
-        setError(errorMessage);
-        debugLog(`Error in ${operation}`, error);
-    }, [debugLog]);
-    // Load images for a specific page
-    const loadPage = useCallback(async (pageNum, isLoadMore = false) => {
-        if (!controllerRef.current || !firebaseUidRef.current || !eventIdRef.current) {
-            debugLog('Load skipped: missing controller, firebaseUid, or eventId');
-            return;
-        }
-        // Set appropriate loading state
-        if (isLoadMore) {
-            setIsLoadingMore(true);
-        }
-        else {
-            setIsLoading(true);
-        }
-        setError(null);
-        try {
-            debugLog(`Loading page ${pageNum}...`, { isLoadMore });
-            const response = await controllerRef.current.getImageList(firebaseUidRef.current, eventIdRef.current, pageNum);
-            debugLog('Page loaded successfully', {
-                page: response.current_page,
-                imageCount: response.gallery.length,
-                hasNext: response.next_page > 0
-            });
-            // Update images list
-            setImages(prev => {
-                if (isLoadMore) {
-                    // Append new images for load more
-                    return [...prev, ...response.gallery];
-                }
-                else {
-                    // Replace all images for initial load or refresh
-                    return response.gallery;
-                }
-            });
-            // Update pagination state
-            setCurrentPage(response.current_page);
-            setHasMore(response.next_page > 0 && response.gallery.length > 0);
-            if (!isInitialized) {
-                setIsInitialized(true);
-            }
-        }
-        catch (err) {
-            handleError(`load page ${pageNum}`, err);
-            // On error, don't change images if it's load more
-            if (!isLoadMore) {
-                setImages([]);
-            }
-        }
-        finally {
-            if (isLoadMore) {
-                setIsLoadingMore(false);
-            }
-            else {
-                setIsLoading(false);
-            }
-        }
-    }, [debugLog, handleError, isInitialized]);
-    // Load more images (next page) - spam-protected
-    const loadMore = useCallback(async () => {
-        // Prevent multiple concurrent loadMore calls
-        if (isLoadMoreRunningRef.current || isLoadingMore || !hasMore) {
-            debugLog('Load more skipped', {
-                isLoadMoreRunning: isLoadMoreRunningRef.current,
-                isLoadingMore,
-                hasMore
-            });
-            return;
-        }
-        // Mark as running to prevent spam
-        isLoadMoreRunningRef.current = true;
-        try {
-            debugLog('Loading more images...', { nextPage: currentPage + 1 });
-            await loadPage(currentPage + 1, true);
-        }
-        finally {
-            // Always reset the running flag
-            isLoadMoreRunningRef.current = false;
-        }
-    }, [isLoadingMore, hasMore, currentPage, loadPage, debugLog]);
-    // Refresh from first page
-    const refresh = useCallback(async () => {
-        debugLog('Refreshing from first page...');
-        setCurrentPage(1);
-        setHasMore(true);
-        await loadPage(1, false);
-    }, [loadPage, debugLog]);
-    // Reset pagination state
-    const reset = useCallback(() => {
-        debugLog('Resetting pagination state');
-        setImages([]);
-        setCurrentPage(1);
-        setHasMore(true);
-        setError(null);
-        setIsInitialized(false);
-        // Reset loadMore running flag when page changes
-        isLoadMoreRunningRef.current = false;
-    }, [debugLog]);
-    // Auto-load first page on initialization
-    useEffect(() => {
-        if (memoizedOptions.autoLoad && controller && firebaseUid && eventId && !isInitialized) {
-            debugLog('Auto-loading first page...');
-            loadPage(1, false);
-        }
-    }, [memoizedOptions.autoLoad, controller, firebaseUid, eventId, isInitialized, loadPage, debugLog]);
-    // Reset when dependencies change (if autoReset is enabled)
-    useEffect(() => {
-        if (memoizedOptions.autoReset && isInitialized) {
-            debugLog('Dependencies changed, resetting state');
-            reset();
-        }
-    }, [controller, firebaseUid, eventId, memoizedOptions.autoReset, isInitialized, reset, debugLog]);
-    // Paging info object - memoized to prevent re-renders
-    const info = useMemo(() => ({
-        isLoading,
-        isLoadingMore,
-        error,
-        currentPage,
-        hasMore,
-        totalImages: images.length,
-        isInitialized
-    }), [isLoading, isLoadingMore, error, currentPage, hasMore, images.length, isInitialized]);
-    // Actions object - memoized to prevent re-renders
-    const actions = useMemo(() => ({
-        loadMore,
-        refresh,
-        reset
-    }), [loadMore, refresh, reset]);
-    // Return object - memoized to prevent re-renders
-    return useMemo(() => ({
-        images,
-        info,
-        actions
-    }), [images, info, actions]);
-}