lisichatbot 1.4.7 → 1.4.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lisichatbot",
-  "version": "1.4.7",
+  "version": "1.4.8",
   "type": "module",
   "main": "./src/index.js",
   "exports": {

package/src/index.js

@@ -1890,77 +1890,88 @@ async function handleNext() {
         const targetStep = chatState.returnToStep;
         console.log(`\n🔙 Returning to saved step ${targetStep} (edited step complete)`);
         
-        // ✅ NEW: Check if there are dependent steps between current and target that should now be shown
-        const currentStepIndex = chatState.step;
-        const editedStepField = flowData.flow[currentStepIndex]?.input?.field;
+        // ✅ Check if we should continue to next step or jump back
+        const nextStep = chatState.step + 1;
         
-        console.log(`   🔍 Checking for dependent steps between ${currentStepIndex} and ${targetStep}`);
-        
-        let nextStepToShow = null;
-        
-        // Check all steps between current and target
-        for (let i = currentStepIndex + 1; i < targetStep; i++) {
-            const step = flowData.flow[i];
+        if (nextStep < targetStep) {
+            // There are steps between current and target
+            const currentStepIndex = chatState.step;
+            const editedStepField = flowData.flow[currentStepIndex]?.input?.field;
             
-            // Check if this step depends on the edited field
-            if (step.dependsOn) {
-                const dependencies = Array.isArray(step.dependsOn) ? step.dependsOn : [step.dependsOn];
+            console.log(`   🔍 Checking if step ${nextStep} should be shown (between ${currentStepIndex} and ${targetStep})`);
+            
+            // Check if the next step depends on the edited field
+            const nextStepConfig = flowData.flow[nextStep];
+            if (nextStepConfig && nextStepConfig.dependsOn) {
+                const dependencies = Array.isArray(nextStepConfig.dependsOn) ? nextStepConfig.dependsOn : [nextStepConfig.dependsOn];
                 
                 if (dependencies.includes(editedStepField)) {
-                    console.log(`   🔗 Found dependent step ${i} (depends on ${editedStepField})`);
+                    console.log(`   🔗 Step ${nextStep} depends on ${editedStepField} - checking shouldDisplay`);
                     
-                    // Check if this step should now be displayed
-                    if (step.shouldDisplay) {
-                        let shouldShow = false;
-                        
-                        if (typeof step.shouldDisplay === 'function') {
+                    // Check shouldDisplay
+                    let shouldShow = true;  // Default to true if no shouldDisplay
+                    
+                    if (nextStepConfig.shouldDisplay) {
+                        if (typeof nextStepConfig.shouldDisplay === 'function') {
                             try {
-                                shouldShow = await step.shouldDisplay(chatState.data);
-                                console.log(`   🔍 Step ${i} shouldDisplay: ${shouldShow}`);
+                                shouldShow = await nextStepConfig.shouldDisplay(chatState.data);
+                                console.log(`   🔍 Step ${nextStep} shouldDisplay: ${shouldShow}`);
                             } catch (error) {
-                                console.error(`Error in shouldDisplay for step ${i}:`, error);
+                                console.error(`Error in shouldDisplay for step ${nextStep}:`, error);
+                                shouldShow = false;
                             }
-                        } else if (typeof step.shouldDisplay === 'boolean') {
-                            shouldShow = step.shouldDisplay;
+                        } else if (typeof nextStepConfig.shouldDisplay === 'boolean') {
+                            shouldShow = nextStepConfig.shouldDisplay;
                         }
+                    }
+                    
+                    if (shouldShow) {
+                        // Show this dependent step, keep returnToStep for later
+                        console.log(`   ✅ Step ${nextStep} should be shown - continuing to it (returnToStep=${targetStep} preserved)`);
+                        chatState.step = nextStep;
                         
-                        if (shouldShow) {
-                            console.log(`   ✅ Step ${i} should now be shown - showing it first`);
-                            nextStepToShow = i;
-                            break;  // Show the first dependent step that should be displayed
-                        } else {
-                            console.log(`   ⏭️ Step ${i} shouldDisplay returned false - skipping`);
-                        }
+                        const allRangeWrappers = document.querySelectorAll('[data-chat-element="range-wrapper"]');
+                        allRangeWrappers.forEach(wrapper => {
+                            wrapper.style.display = 'none';
+                        });
+                        
+                        updateEditIcons();
+                        await showNextStep();
+                        return;
                     } else {
-                        // No shouldDisplay means always show
-                        console.log(`   ✅ Step ${i} has no shouldDisplay - showing it`);
-                        nextStepToShow = i;
-                        break;
+                        console.log(`   ⏭️ Step ${nextStep} shouldDisplay returned false - will check next step`);
                     }
                 }
             }
-        }
-        
-        if (nextStepToShow !== null) {
-            // Show the dependent step that should be displayed
-            console.log(`   🔄 Showing dependent step ${nextStepToShow} before returning to ${targetStep}`);
-            chatState.step = nextStepToShow;
+            
+            // Next step doesn't depend on edited field or shouldn't be shown
+            // Continue to next step normally (it will check shouldDisplay in showNextStep)
+            console.log(`   ➡️ Continuing to next step ${nextStep} (normal flow)`);
+            chatState.step = nextStep;
+            
+            const allRangeWrappers = document.querySelectorAll('[data-chat-element="range-wrapper"]');
+            allRangeWrappers.forEach(wrapper => {
+                wrapper.style.display = 'none';
+            });
+            
+            updateEditIcons();
+            await showNextStep();
+            return;
         } else {
-            // No dependent steps to show, return to target
-            console.log(`   ⏭️ No dependent steps to show, returning directly to step ${targetStep}`);
+            // Reached or passed target, clear returnToStep and go to target
+            console.log(`   ⏭️ Reached target, returning to step ${targetStep}`);
             chatState.returnToStep = null;
             chatState.step = targetStep;
+            
+            const allRangeWrappers = document.querySelectorAll('[data-chat-element="range-wrapper"]');
+            allRangeWrappers.forEach(wrapper => {
+                wrapper.style.display = 'none';
+            });
+            
+            updateEditIcons();
+            await showNextStep();
+            return;
         }
-        
-        const allRangeWrappers = document.querySelectorAll('[data-chat-element="range-wrapper"]');
-        allRangeWrappers.forEach(wrapper => {
-            wrapper.style.display = 'none';
-        });
-        console.log('  🙈 Hidden all range-wrappers');
-        
-        updateEditIcons();
-        await showNextStep();
-        return;
     }
 
     chatState.step++;