@yogiswara/honcho-editor-ui 3.3.3 → 3.4.0

package/dist/hooks/editor/useHonchoEditorBulk.js

@@ -4,8 +4,10 @@ import { useAdjustmentHistoryBatch } from '../useAdjustmentHistoryBatch';
 import { usePaging } from "../usePaging";
 import { usePreset } from "../usePreset";
 import { mapAdjustmentStateToAdjustmentEditor } from "../../utils/adjustment";
+import { log } from '../../utils/logger';
 // Helper function to map the API response to the format our UI component needs
 const mapGalleryToPhotoData = (gallery, selectedIds) => {
+    log.debug({ gallery }, "[useHonchoEditorBulk] mapGalleryToPhotoData");
     return {
         key: gallery.id,
         src: gallery.raw_thumbnail?.path ? gallery.raw_thumbnail.path : gallery.thumbnail?.path,
@@ -17,13 +19,31 @@ const mapGalleryToPhotoData = (gallery, selectedIds) => {
         adjustments: gallery.editor_config?.color_adjustment,
     };
 };
+// Helper function to map PhotoData to GallerySetup format for AlbumImageGalleryInfinite
+// PhotoData already contains the correct adjustments from history (processed in imageData useMemo)
+const mapPhotoDataToGallerySetup = (photoData) => {
+    log.debug({ photoData }, "[useHonchoEditorBulk] mapPhotoDataToGallerySetup");
+    return {
+        src: photoData.src,
+        original: photoData.original,
+        srcSet: undefined,
+        sizes: undefined,
+        width: photoData.width,
+        height: photoData.height,
+        alt: photoData.alt,
+        key: photoData.key,
+        frame: undefined,
+        isSelected: photoData.isSelected,
+        adjustments: photoData.adjustments, // Already contains history adjustments if available
+    };
+};
 const mapToImageAdjustmentConfig = (gallery) => {
     return {
         imageId: gallery.id,
-        adjustment: mapColorAdjustmentToAdjustmentState(gallery.editor_config?.color_adjustment),
+        adjustment: mapColorAdjustmentToAdjustmentState(gallery.editor_config?.color_adjustment, gallery.editor_config?.preset_id),
     };
 };
-function mapColorAdjustmentToAdjustmentState(adj) {
+function mapColorAdjustmentToAdjustmentState(adj, preset_id) {
     if (!adj)
         return undefined;
     return {
@@ -39,6 +59,7 @@ function mapColorAdjustmentToAdjustmentState(adj) {
         contrastScore: adj.contrast || 0,
         clarityScore: adj.clarity || 0,
         sharpnessScore: adj.sharpness || 0,
+        preset_id: preset_id,
     };
 }
 // Helper function to convert Preset to AdjustmentState
@@ -59,14 +80,53 @@ const presetToAdjustmentState = (preset) => {
     };
 };
 // Helper function to compare adjustment states
-const adjustmentsMatch = (a, b) => {
-    const keys = [
-        'tempScore', 'tintScore', 'vibranceScore', 'saturationScore',
-        'exposureScore', 'highlightsScore', 'shadowsScore', 'whitesScore',
-        'blacksScore', 'contrastScore', 'clarityScore', 'sharpnessScore'
-    ];
-    return keys.every(key => (a[key] || 0) === (b[key] || 0));
+// Remove adjustmentsMatch function as we now use preset_id based comparison
+/**
+ * Helper function to get current adjustments from selected images
+ * Returns the common adjustments or zero values if images have different adjustments
+ */
+const getCurrentAdjustmentsForCopy = (selectedIds, currentBatch) => {
+    if (selectedIds.length === 0) {
+        return {
+            tempScore: 0, tintScore: 0, vibranceScore: 0, saturationScore: 0,
+            exposureScore: 0, highlightsScore: 0, shadowsScore: 0, whitesScore: 0,
+            blacksScore: 0, contrastScore: 0, clarityScore: 0, sharpnessScore: 0,
+        };
+    }
+    // Get adjustments from the first selected image
+    const firstImageId = selectedIds[0];
+    const firstImageAdjustments = currentBatch.allImages[firstImageId];
+    if (!firstImageAdjustments) {
+        return {
+            tempScore: 0, tintScore: 0, vibranceScore: 0, saturationScore: 0,
+            exposureScore: 0, highlightsScore: 0, shadowsScore: 0, whitesScore: 0,
+            blacksScore: 0, contrastScore: 0, clarityScore: 0, sharpnessScore: 0,
+        };
+    }
+    // If only one image is selected, return its adjustments
+    if (selectedIds.length === 1) {
+        return firstImageAdjustments;
+    }
+    // If multiple images are selected, check if they all have the same adjustments
+    // If not, return zero values (indicating mixed adjustments)
+    const allSame = selectedIds.slice(1).every(imageId => {
+        const imageAdjustments = currentBatch.allImages[imageId];
+        if (!imageAdjustments)
+            return false;
+        return Object.keys(firstImageAdjustments).every(key => {
+            return firstImageAdjustments[key] ===
+                imageAdjustments[key];
+        });
+    });
+    return allSame ? firstImageAdjustments : {
+        tempScore: 0, tintScore: 0, vibranceScore: 0, saturationScore: 0,
+        exposureScore: 0, highlightsScore: 0, shadowsScore: 0, whitesScore: 0,
+        blacksScore: 0, contrastScore: 0, clarityScore: 0, sharpnessScore: 0,
+    };
 };
+/**
+ * Helper function to create selective adjustments based on checkboxes
+ */
 /**
  * Hook for bulk photo editing with multi-image backend synchronization.
  *
@@ -83,166 +143,257 @@ const adjustmentsMatch = (a, b) => {
  * - Comprehensive logging of multi-image operations
  */
 export function useHonchoEditorBulk(controller, eventID, firebaseUid) {
-    console.log('[useHonchoEditorBulk] 🏭 Initializing with controller for multi-image backend sync');
-    const { currentBatch, selectedIds, actions: batchActions, historyInfo } = useAdjustmentHistoryBatch({
-        controller,
-        firebaseUid,
-        eventId: eventID,
-        devWarnings: true
-    });
+    const { state, actions: batchActions } = useAdjustmentHistoryBatch(controller, firebaseUid, eventID);
+    const { currentBatch, selectedIds } = state;
     const { images, info, actions } = usePaging(controller, firebaseUid, eventID, {
         autoLoad: true,
-        autoReset: false // Prevent auto-reset to avoid loops
+        autoReset: false, // Prevent auto-reset to avoid loops
     });
     // Preset management
     const { presets, actions: presetActions } = usePreset(controller, firebaseUid, {
         autoLoad: true,
-        devWarnings: true
     });
     // Track which images have been synced to prevent loops
     const lastSyncedImageIds = useRef(new Set());
-    // State for Bulk Editing  
+    // State for Bulk Editing
     const [selectedBulkPreset, setSelectedBulkPreset] = useState('');
-    // Calculate active preset based on selected images' adjustments
+    // Calculate current adjustments for copy operations
+    const currentAdjustments = useMemo(() => {
+        return getCurrentAdjustmentsForCopy(selectedIds, currentBatch);
+    }, [selectedIds, currentBatch]);
+    // Calculate active preset based on preset_id from history (not value comparison)
     const activePreset = useMemo(() => {
         if (selectedIds.length === 0) {
             return null;
         }
-        // Get adjustments for all selected images
-        const selectedAdjustments = selectedIds.map(imageId => {
-            return currentBatch.allImages[imageId] || {
-                tempScore: 0, tintScore: 0, vibranceScore: 0, saturationScore: 0,
-                exposureScore: 0, highlightsScore: 0, shadowsScore: 0, whitesScore: 0,
-                blacksScore: 0, contrastScore: 0, clarityScore: 0, sharpnessScore: 0,
-            };
+        // Get preset_id for all selected images from current batch
+        const selectedPresetIds = selectedIds.map(imageId => {
+            const adjustment = currentBatch.allImages[imageId];
+            return adjustment?.preset_id;
         });
-        // Check if all selected images have the same adjustments
-        const firstAdjustment = selectedAdjustments[0];
-        const allSameAdjustments = selectedAdjustments.every(adj => adjustmentsMatch(adj, firstAdjustment));
-        if (!allSameAdjustments) {
-            // Selected images have different adjustments
+        // Get the first preset_id to compare against
+        const firstPresetId = selectedPresetIds[0];
+        // Check if all selected images have the same preset_id
+        const allSamePresetId = selectedPresetIds.every(presetId => presetId === firstPresetId);
+        if (!allSamePresetId || !firstPresetId) {
+            // Either not all images have the same preset_id, or no preset_id at all
             return null;
         }
-        // Find preset that matches the common adjustment state
-        const matchingPreset = presets.find(preset => {
-            const presetAdjustments = presetToAdjustmentState(preset);
-            return adjustmentsMatch(presetAdjustments, firstAdjustment);
-        });
+        // Find the preset that matches the common preset_id
+        const matchingPreset = presets.find(preset => preset.id === firstPresetId);
+        log.debug({
+            selectedIds,
+            selectedPresetIds,
+            firstPresetId,
+            allSamePresetId,
+            matchingPreset: matchingPreset?.name || 'none',
+            selectedImageAdjustments: selectedIds.map(id => ({
+                imageId: id,
+                preset_id: currentBatch.allImages[id]?.preset_id,
+                hasAdjustment: !!currentBatch.allImages[id]
+            }))
+        }, '[useHonchoEditorBulk] 🎨 Active preset calculation');
         return matchingPreset || null;
     }, [selectedIds, currentBatch.allImages, presets]);
     // Update selectedBulkPreset when activePreset changes
     useEffect(() => {
-        setSelectedBulkPreset(activePreset?.id || '');
+        const newPresetId = activePreset?.id || '';
+        setSelectedBulkPreset(newPresetId);
+        log.debug({
+            activePreset: activePreset?.name || 'none',
+            presetId: newPresetId,
+            selectedImagesCount: selectedIds.length,
+            triggerReason: 'activePreset changed'
+        }, '[useHonchoEditorBulk] 🎨 Preset selection updated');
     }, [activePreset]);
     // Use loading states from usePaging instead of local state
     const isLoading = info.isLoading;
     const error = info.error;
     const hasMore = info.hasMore;
     const imageData = useMemo(() => {
-        // console.debug("imageData recalculating with:", {
-        //     imagesLength: images.length,
-        //     selectedIds,
-        //     currentBatch_allImages: currentBatch.allImages,
-        //     currentBatch_allImages_keys: Object.keys(currentBatch.allImages)
-        // });
         const res = images.map(item => {
             const basePhoto = mapGalleryToPhotoData(item, selectedIds);
-            const batchAdjustment = currentBatch.allImages[item.id];
-            if (batchAdjustment) {
-                const adjustmentsValues = mapAdjustmentStateToAdjustmentEditor(batchAdjustment);
+            const historyAdjustment = currentBatch.allImages[item.id];
+            // **ADJUSTMENT PRIORITY LOGIC**
+            // 1. History adjustments (from useAdjustmentHistoryBatch) - highest priority
+            //    These are the most current client-side changes that may not be saved to backend yet
+            // 2. Backend adjustments (from paging data) - fallback
+            //    These come from the server and represent previously saved adjustments
+            //
+            // This ensures that when user makes adjustments in the UI, they are immediately
+            // reflected in the gallery view even before they're synced to the backend.
+            if (historyAdjustment) {
+                // Use adjustments from history (most current client-side changes)
+                // Convert AdjustmentState (from history) to AdjustmentValues (for UI)
+                const adjustmentsValues = mapAdjustmentStateToAdjustmentEditor(historyAdjustment);
                 basePhoto.adjustments = adjustmentsValues;
+                log.debug({
+                    historyAdjustment,
+                    convertedValues: adjustmentsValues
+                }, `[useHonchoEditorBulk] 📊 Image ${item.id} using HISTORY adjustments`);
+            }
+            else {
+                // Fall back to backend adjustments if no history exists for this image
+                // basePhoto.adjustments already contains backend data from mapGalleryToPhotoData
+                log.debug({
+                    backendAdjustments: basePhoto.adjustments
+                }, `[useHonchoEditorBulk] 📊 Image ${item.id} using BACKEND adjustments`);
             }
-            // Merge batch adjustments over backend adjustments
-            return batchAdjustment ? { ...basePhoto } : basePhoto;
+            return basePhoto;
         });
+        log.debug({
+            totalImages: res.length,
+            imagesWithHistory: res.filter(img => currentBatch.allImages[img.key]).length,
+            imagesWithBackendOnly: res.filter(img => !currentBatch.allImages[img.key] && img.adjustments).length,
+            imagesWithNoAdjustments: res.filter(img => !currentBatch.allImages[img.key] && !img.adjustments).length
+        }, '[useHonchoEditorBulk] 📊 ImageData construction summary');
         return res;
     }, [images, selectedIds, currentBatch.allImages]);
-    // Store the latest batchActions.syncAdjustment in a ref to avoid dependency issues
+    // Convert imageData (PhotoData[]) to GallerySetup[] for AlbumImageGalleryInfinite
+    const gallerySetupData = useMemo(() => {
+        const result = imageData.map(mapPhotoDataToGallerySetup);
+        log.debug({
+            photoDataCount: imageData.length,
+            gallerySetupCount: result.length,
+            batchImageCount: Object.keys(currentBatch.allImages).length,
+            samplePhotoData: imageData[0] ? {
+                key: imageData[0].key,
+                src: imageData[0].src,
+                isSelected: imageData[0].isSelected,
+                hasAdjustments: !!imageData[0].adjustments
+            } : null,
+            sampleGallerySetup: result[0] ? {
+                key: result[0].key,
+                src: result[0].src,
+                isSelected: result[0].isSelected,
+                hasAdjustments: !!result[0].adjustments,
+                adjustmentsSource: currentBatch.allImages[result[0].key] ? 'history' : 'backend'
+            } : null
+        }, '[useHonchoEditorBulk] 🔄 Mapped PhotoData to GallerySetup');
+        return result;
+    }, [imageData, currentBatch.allImages]);
+    // Store the latest batchActions functions in refs to avoid dependency issues
     const syncAdjustmentRef = useRef(batchActions.syncAdjustment);
+    const initializeFromPaginationRef = useRef(batchActions.initializeFromPagination);
     syncAdjustmentRef.current = batchActions.syncAdjustment;
+    initializeFromPaginationRef.current = batchActions.initializeFromPagination;
     // Safe sync: Only sync new images to prevent infinite loops
     useEffect(() => {
-        console.log('[useHonchoEditorBulk] 🔄 Sync effect triggered:', {
+        log.debug({
             imagesLength: images.length,
             imageIds: images.map(img => img.id),
             lastSyncedImageIds: Array.from(lastSyncedImageIds.current),
             lastSyncedCount: lastSyncedImageIds.current.size
-        });
+        }, '[useHonchoEditorBulk] 🔄 Sync effect triggered');
         if (images.length === 0)
             return;
         // Check if we have new images that haven't been synced
         const currentImageIds = new Set(images.map(img => img.id));
         const hasNewImages = images.some(img => !lastSyncedImageIds.current.has(img.id));
-        console.log('[useHonchoEditorBulk] 🔍 New images check:', {
+        log.debug({
             currentImageIds: Array.from(currentImageIds),
             hasNewImages,
             newImages: images.filter(img => !lastSyncedImageIds.current.has(img.id)).map(img => img.id)
-        });
+        }, '[useHonchoEditorBulk] 🔍 New images check');
         if (hasNewImages) {
-            console.log('[useHonchoEditorBulk] ⚠️ SYNC TRIGGER: Syncing new images to batch (THIS RESETS HISTORY!):', images.length);
-            syncAdjustmentRef.current(images.map(mapToImageAdjustmentConfig));
+            log.info({ imageCount: images.length }, '[useHonchoEditorBulk] 🔄 INITIALIZE: Initializing new images from pagination data (preserves history)');
+            initializeFromPaginationRef.current(images.map(mapToImageAdjustmentConfig));
             lastSyncedImageIds.current = currentImageIds;
         }
         else {
-            console.log('[useHonchoEditorBulk] ✅ No new images, skipping sync (history preserved)');
+            log.debug('[useHonchoEditorBulk] ✅ No new images, skipping initialization (history preserved)');
         }
     }, [images]); // Only depend on images, not batchActions
+    const clearSelection = useCallback(() => {
+        log.info({
+            currentlySelected: selectedIds.length,
+            selectedImageIds: selectedIds
+        }, '[useHonchoEditorBulk] Clearing all selections');
+        // If there are selected images, toggle them off one by one
+        if (selectedIds.length > 0) {
+            selectedIds.forEach(imageId => {
+                batchActions.toggleSelection(imageId);
+            });
+        }
+        log.info('[useHonchoEditorBulk] All selections cleared');
+    }, [selectedIds, batchActions]);
+    const selectAllImages = useCallback(() => {
+        log.info({
+            totalImages: gallerySetupData.length,
+            currentlySelected: selectedIds.length,
+            availableImageIds: gallerySetupData.map(img => img.key)
+        }, '[useHonchoEditorBulk] Selecting all images');
+        // Get all image IDs from gallerySetupData
+        const allImageIds = gallerySetupData.map(image => image.key);
+        if (allImageIds.length === 0) {
+            log.warn('[useHonchoEditorBulk] No images available to select');
+            return;
+        }
+        // Find images that are not currently selected and select them
+        const unselectedImages = allImageIds.filter(imageId => !selectedIds.includes(imageId));
+        unselectedImages.forEach(imageId => {
+            batchActions.toggleSelection(imageId);
+        });
+        log.info({
+            selectedCount: allImageIds.length,
+            newlySelected: unselectedImages.length
+        }, '[useHonchoEditorBulk] All images selected');
+    }, [gallerySetupData, selectedIds, batchActions]);
     const handleBackCallbackBulk = useCallback(() => {
         const lastSelectedId = selectedIds.length > 0 ? selectedIds[selectedIds.length - 1] : "";
         controller.handleBack(firebaseUid, lastSelectedId);
     }, [controller, firebaseUid, selectedIds]);
-    const handleSelectBulkPreset = useCallback((event) => {
-        const presetId = event.target.value;
+    const handleSelectBulkPreset = useCallback((presetId) => {
         setSelectedBulkPreset(presetId);
-        console.log('[useHonchoEditorBulk] 🎨 Preset selection attempt:', {
+        log.info({
             presetId,
             selectedImages: selectedIds,
             imageCount: selectedIds.length,
             hasController: !!controller,
             hasFirebaseUid: !!firebaseUid
-        });
+        }, '[useHonchoEditorBulk] 🎨 Preset selection attempt');
         if (!presetId) {
-            console.log('[useHonchoEditorBulk] ❌ No preset ID provided, skipping backend call');
+            log.warn('[useHonchoEditorBulk] ❌ No preset ID provided, skipping backend call');
             return;
         }
         if (selectedIds.length === 0) {
-            console.log('[useHonchoEditorBulk] ❌ No images selected, skipping backend call');
+            log.warn('[useHonchoEditorBulk] ❌ No images selected, skipping backend call');
             return;
         }
-        console.log('[useHonchoEditorBulk] 🎨 Applying preset to multiple images:', {
+        log.info({
             presetId,
             selectedImages: selectedIds,
             imageCount: selectedIds.length
-        });
+        }, '[useHonchoEditorBulk] 🎨 Applying preset to multiple images');
         // Find the preset
         const preset = presets.find(p => p.id === presetId);
         if (!preset) {
-            console.log('[useHonchoEditorBulk] ❌ Preset not found in presets list:', presetId);
+            log.error({ presetId }, '[useHonchoEditorBulk] ❌ Preset not found in presets list');
             return;
         }
         // Convert preset to adjustment state
         const presetAdjustments = presetToAdjustmentState(preset);
-        console.log('[useHonchoEditorBulk] 📤 Sending preset adjustments to controller for each image:', presetAdjustments);
-        console.log('[useHonchoEditorBulk] 🔄 About to call batchActions.adjustSelectedWithPreset');
+        log.debug({ presetAdjustments }, '[useHonchoEditorBulk] 📤 Sending preset adjustments to controller for each image');
+        log.debug('[useHonchoEditorBulk] 🔄 About to call batchActions.adjustSelectedWithPreset');
         // Apply preset directly to all selected images using the clean action
         // This will trigger backend calls for each selected image via adjustSelectedWithPreset
-        batchActions.adjustSelectedWithPreset(presetAdjustments);
-        console.log('[useHonchoEditorBulk] ✅ Called batchActions.adjustSelectedWithPreset, backend calls should be triggered');
+        batchActions.adjustSelectedWithPreset(presetAdjustments, preset.id);
+        log.info('[useHonchoEditorBulk] ✅ Called batchActions.adjustSelectedWithPreset, backend calls should be triggered');
     }, [presets, selectedIds, batchActions, controller, firebaseUid]);
     // This factory creates functions that adjust a value for all selected images
     const createRelativeAdjuster = useCallback((key, amount) => () => {
-        console.debug(`[useHonchoEditorBulk] 🎛️ Bulk ${key} adjustment:`, {
+        log.debug({
             key,
             amount,
             selectedImages: selectedIds,
             imageCount: selectedIds.length
-        });
-        console.debug('[useHonchoEditorBulk] 📤 Sending bulk adjustment to controller for each selected image');
-        console.debug("currentBatch.allImages before:", currentBatch.allImages);
+        }, `[useHonchoEditorBulk] 🎛️ Bulk ${key} adjustment`);
+        log.debug('[useHonchoEditorBulk] 📤 Sending bulk adjustment to controller for each selected image');
+        log.debug({ allImages: currentBatch.allImages }, "currentBatch.allImages before");
         batchActions.adjustSelected({ [key]: amount });
         // Debug after a short delay to see if the state changed
         setTimeout(() => {
-            console.debug("currentBatch.allImages after:", currentBatch.allImages);
+            log.debug({ allImages: currentBatch.allImages }, "currentBatch.allImages after");
         }, 100);
     }, [batchActions, selectedIds, currentBatch.allImages]);
     const handleBulkTempDecreaseMax = createRelativeAdjuster('tempScore', -20);
@@ -293,50 +444,10 @@ export function useHonchoEditorBulk(controller, eventID, firebaseUid) {
     const handleBulkSharpnessDecrease = createRelativeAdjuster('sharpnessScore', -5);
     const handleBulkSharpnessIncrease = createRelativeAdjuster('sharpnessScore', 5);
     const handleBulkSharpnessIncreaseMax = createRelativeAdjuster('sharpnessScore', 20);
-    // const loadImages = useCallback(async (pageNum: number) => {
-    //     // Use the correct loading state
-    //     if (pageNum === 1) {
-    //         setIsLoading(true);
-    //     } else {
-    //         setIsFetchingMore(true);
-    //     }
-    //     setError(null);
-    //     try {
-    //         const response = await controller.getImageList(firebaseUid, eventID, pageNum);
-    //         // Sync adjustments for the new images with the batch history
-    //         batchActions.syncAdjustment(response.gallery.map(mapToImageAdjustmentConfig));
-    //         // Append new images for page > 1, otherwise replace
-    //         setImageCollection(prev => pageNum === 1 ? response.gallery : [...prev, ...response.gallery]);
-    //         setPage(response.current_page);
-    //         setHasMore(response.next_page > 0 && response.gallery.length > 0);
-    //     } catch (err: any) {
-    //         console.error("Failed to fetch image list:", err);
-    //         setError(err.message || "Could not load images.");
-    //     } finally {
-    //         if (pageNum === 1) {
-    //             setIsLoading(false);
-    //         } else {
-    //             setIsFetchingMore(false);
-    //         }
-    //     }
-    // }, [controller, firebaseUid, eventID, batchActions]);
-    // const loadMoreImages = useCallback(() => {
-    //     if (!isFetchingMore && hasMore) {
-    //         loadImages(page + 1);
-    //     }
-    // }, [isFetchingMore, hasMore, page, loadImages]);
-    // Note: Image loading is now handled by usePaging hook
-    // The sync logic above handles syncing loaded images to batch state
-    // useEffect(() => {
-    //     if (eventID && firebaseUid) {
-    //         setImageCollection([]); // reset when event changes
-    //         setPage(1);
-    //         loadImages(1);
-    //     }
-    // }, [eventID, firebaseUid, loadImages]);
     return {
         imageData,
         isLoading,
+        isLoadingMore: info.isLoadingMore,
         error,
         selectedIds,
         hasMore,
@@ -348,6 +459,8 @@ export function useHonchoEditorBulk(controller, eventID, firebaseUid) {
         selectedBulkPreset,
         activePreset,
         handleSelectBulkPreset,
+        clearSelection,
+        selectAllImages,
         // Preset creation handlers
         presetActions, // Expose preset actions for create/rename/delete
         handleToggleImageSelection: batchActions.toggleSelection,
@@ -404,24 +517,30 @@ export function useHonchoEditorBulk(controller, eventID, firebaseUid) {
         handleBulkSharpnessDecrease,
         handleBulkSharpnessIncrease,
         handleBulkSharpnessIncreaseMax,
+        // Adjustment History
+        createRelativeAdjuster,
+        // copy paste
+        // copiedAdjustments,
+        currentAdjustments,
         // History actions
-        handleUndo: () => {
-            console.log('[useHonchoEditorBulk] ⏪ Undo requested for multiple images:', {
-                selectedImages: selectedIds,
-                imageCount: selectedIds.length
-            });
-            console.log('[useHonchoEditorBulk] 📤 Sending undo (setHistoryIndex) to controller for each image');
-            return batchActions.undo();
-        },
-        handleRedo: () => {
-            console.log('[useHonchoEditorBulk] ⏩ Redo requested for multiple images:', {
-                selectedImages: selectedIds,
-                imageCount: selectedIds.length
-            });
-            console.log('[useHonchoEditorBulk] 📤 Sending redo (setHistoryIndex) to controller for each image');
-            return batchActions.redo();
-        },
+        handleUndo: batchActions.undo,
+        handleRedo: batchActions.redo,
         handleReset: batchActions.reset,
-        historyInfo,
+        historyInfo: {
+            canUndo: state.canUndo,
+            canRedo: state.canRedo,
+            currentIndex: state.currentIndex,
+            totalStates: state.totalStates,
+            selectedCount: state.selectedCount,
+            totalImages: state.totalImages,
+            historySize: state.historySize
+        },
+        // Socket updates
+        updateFromSocket: batchActions.updateFromSocket,
+        adjustSelected: batchActions.adjustSelected,
+        adjustSelectedWithPreset: batchActions.adjustSelectedWithPreset,
+        adjustSelectedWithPaste: batchActions.adjustSelectedWithPaste,
+        // Gallery setup data for AlbumImageGalleryInfinite
+        gallerySetupData,
     };
 }

package/dist/hooks/useAdjustmentHistory.js

@@ -4,18 +4,18 @@ import { useState, useCallback, useMemo, useRef, useEffect } from 'react';
  */
 const convertAdjustmentStateToColorAdjustment = (adjustmentState) => {
     return {
-        temperature: adjustmentState.tempScore,
-        tint: adjustmentState.tintScore,
-        saturation: adjustmentState.saturationScore,
-        vibrance: adjustmentState.vibranceScore,
-        exposure: adjustmentState.exposureScore,
-        contrast: adjustmentState.contrastScore,
-        highlights: adjustmentState.highlightsScore,
-        shadows: adjustmentState.shadowsScore,
-        whites: adjustmentState.whitesScore,
-        blacks: adjustmentState.blacksScore,
-        clarity: adjustmentState.clarityScore,
-        sharpness: adjustmentState.sharpnessScore,
+        temperature: adjustmentState.tempScore || 0,
+        tint: adjustmentState.tintScore || 0,
+        saturation: adjustmentState.saturationScore || 0,
+        vibrance: adjustmentState.vibranceScore || 0,
+        exposure: adjustmentState.exposureScore || 0,
+        contrast: adjustmentState.contrastScore || 0,
+        highlights: adjustmentState.highlightsScore || 0,
+        shadows: adjustmentState.shadowsScore || 0,
+        whites: adjustmentState.whitesScore || 0,
+        blacks: adjustmentState.blacksScore || 0,
+        clarity: adjustmentState.clarityScore || 0,
+        sharpness: adjustmentState.sharpnessScore || 0,
     };
 };
 /**