@yogiswara/honcho-editor-ui 3.4.15 → 3.4.17

package/dist/hooks/editor/useHonchoEditorBulk.d.ts

@@ -61,6 +61,7 @@ export declare function useHonchoEditorBulk(controller: Controller, eventID: str
     presets: Preset[];
     selectedBulkPreset: string;
     activePreset: Preset | null;
+    presetSummary: string;
     handleSelectBulkPreset: (presetId: string) => void;
     clearSelection: () => void;
     selectAllImages: () => void;

package/dist/hooks/editor/useHonchoEditorBulk.js

@@ -161,39 +161,87 @@ export function useHonchoEditorBulk(controller, eventID, firebaseUid) {
     const currentAdjustments = useMemo(() => {
         return getCurrentAdjustmentsForCopy(selectedIds, currentBatch);
     }, [selectedIds, currentBatch]);
+    const areAdjustmentsEqual = (adj1, adj2) => {
+        // The fix is to use this more specific type for our keys array
+        const keys = [
+            'tempScore', 'tintScore', 'saturationScore', 'vibranceScore',
+            'exposureScore', 'contrastScore', 'highlightsScore', 'shadowsScore',
+            'whitesScore', 'blacksScore', 'clarityScore', 'sharpnessScore'
+        ];
+        for (const key of keys) {
+            // Now, TypeScript knows `key` can't be 'preset_id', so adj1[key] will be a number.
+            if (Math.round(adj1[key] || 0) !== Math.round(adj2[key] || 0)) {
+                return false;
+            }
+        }
+        return true;
+    };
     // Calculate active preset based on preset_id from history (not value comparison)
-    const activePreset = useMemo(() => {
+    const { activePreset, presetSummary } = useMemo(() => {
         if (selectedIds.length === 0) {
-            return null;
+            return { activePreset: null, presetSummary: 'NO_SELECTION' };
         }
-        // Get preset_id for all selected images from current batch
-        const selectedPresetIds = selectedIds.map(imageId => {
-            const adjustment = currentBatch.allImages[imageId];
-            return adjustment?.preset_id;
+        const imageDetails = selectedIds.map(id => {
+            const adjustment = currentBatch.allImages[id];
+            const presetId = adjustment?.preset_id || null;
+            // Check if preset exists in our presets list
+            const matchingPreset = presetId ? presets.find(p => p.id === presetId) : null;
+            // Check if the adjustment values actually match the preset values
+            let hasValidMatchingPreset = false;
+            if (matchingPreset && adjustment) {
+                const presetAdjustments = presetToAdjustmentState(matchingPreset);
+                hasValidMatchingPreset = areAdjustmentsEqual(adjustment, presetAdjustments);
+            }
+            return {
+                imageId: id,
+                presetId,
+                matchingPreset,
+                hasValidMatchingPreset,
+                adjustmentValues: adjustment
+            };
         });
-        // 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 the preset that matches the common preset_id
-        const matchingPreset = presets.find(preset => preset.id === firstPresetId);
-        log.debug({
+        console.log('Debug preset calculation (with custom check):', {
             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]
+            imageDetails: imageDetails.map(detail => ({
+                imageId: detail.imageId,
+                presetId: detail.presetId,
+                presetName: detail.matchingPreset?.name || 'N/A',
+                hasValidMatchingPreset: detail.hasValidMatchingPreset,
+                isCustomAdjustment: detail.presetId && !detail.hasValidMatchingPreset
             }))
-        }, '[useHonchoEditorBulk] 🎨 Active preset calculation');
-        return matchingPreset || null;
+        });
+        // Get images that have ACTUALLY matching presets (not just preset IDs)
+        const imagesWithValidPresets = imageDetails.filter(detail => detail.hasValidMatchingPreset);
+        const validPresetIds = imagesWithValidPresets.map(detail => detail.presetId);
+        const uniqueValidPresetIds = new Set(validPresetIds);
+        // Case 1: No images have actually matching presets
+        // This includes: no preset_id, non-existent preset_id, or preset_id with modified values
+        if (imagesWithValidPresets.length === 0) {
+            console.log('Case 1: No images have valid matching presets - showing Select');
+            return { activePreset: null, presetSummary: 'NO_SELECTION' };
+        }
+        // Case 2: Some images have valid matching presets, some don't (mixed state)
+        if (imagesWithValidPresets.length > 0 && imagesWithValidPresets.length < selectedIds.length) {
+            console.log('Case 2: Mixed preset state (some valid, some custom/none) - showing Multiple presets');
+            return { activePreset: null, presetSummary: 'MULTIPLE_PRESETS' };
+        }
+        // Case 3: All images have valid matching presets, but different ones
+        if (uniqueValidPresetIds.size > 1) {
+            console.log('Case 3: Multiple different valid presets - showing Multiple presets');
+            return { activePreset: null, presetSummary: 'MULTIPLE_PRESETS' };
+        }
+        // Case 4: All images have the same valid matching preset
+        const singleValidPresetId = Array.from(uniqueValidPresetIds)[0];
+        const matchingPreset = presets.find(p => p.id === singleValidPresetId);
+        if (matchingPreset) {
+            console.log('Case 4: All images have the same valid matching preset');
+            return { activePreset: matchingPreset, presetSummary: 'SINGLE' };
+        }
+        else {
+            // This shouldn't happen given our filtering above, but safety check
+            console.log('Case 4 safety check failed - showing Select');
+            return { activePreset: null, presetSummary: 'NO_SELECTION' };
+        }
     }, [selectedIds, currentBatch.allImages, presets]);
     // Update selectedBulkPreset when activePreset changes
     useEffect(() => {
@@ -458,6 +506,7 @@ export function useHonchoEditorBulk(controller, eventID, firebaseUid) {
         presets,
         selectedBulkPreset,
         activePreset,
+        presetSummary,
         handleSelectBulkPreset,
         clearSelection,
         selectAllImages,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yogiswara/honcho-editor-ui",
-  "version": "3.4.15",
+  "version": "3.4.17",
   "description": "A complete UI component library for the Honcho photo editor.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",