lisichatbot 1.4.5 → 1.4.7

package/package.json

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

package/src/index.js

@@ -1889,24 +1889,78 @@ async function handleNext() {
     if (chatState.returnToStep !== null) {
         const targetStep = chatState.returnToStep;
         console.log(`\n🔙 Returning to saved step ${targetStep} (edited step complete)`);
-        chatState.returnToStep = null;
         
-        if (targetStep >= 0 && targetStep < flowData.flow.length) {
-            chatState.step = targetStep;
-            console.log(`   ✅ Jumped to step ${targetStep}`);
-            
-            const allRangeWrappers = document.querySelectorAll('[data-chat-element="range-wrapper"]');
-            allRangeWrappers.forEach(wrapper => {
-                wrapper.style.display = 'none';
-            });
-            console.log('  🙈 Hidden all range-wrappers');
+        // ✅ 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;
+        
+        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];
             
-            updateEditIcons();
-            await showNextStep();
-            return;
+            // Check if this step depends on the edited field
+            if (step.dependsOn) {
+                const dependencies = Array.isArray(step.dependsOn) ? step.dependsOn : [step.dependsOn];
+                
+                if (dependencies.includes(editedStepField)) {
+                    console.log(`   🔗 Found dependent step ${i} (depends on ${editedStepField})`);
+                    
+                    // Check if this step should now be displayed
+                    if (step.shouldDisplay) {
+                        let shouldShow = false;
+                        
+                        if (typeof step.shouldDisplay === 'function') {
+                            try {
+                                shouldShow = await step.shouldDisplay(chatState.data);
+                                console.log(`   🔍 Step ${i} shouldDisplay: ${shouldShow}`);
+                            } catch (error) {
+                                console.error(`Error in shouldDisplay for step ${i}:`, error);
+                            }
+                        } else if (typeof step.shouldDisplay === 'boolean') {
+                            shouldShow = step.shouldDisplay;
+                        }
+                        
+                        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`);
+                        }
+                    } else {
+                        // No shouldDisplay means always show
+                        console.log(`   ✅ Step ${i} has no shouldDisplay - showing it`);
+                        nextStepToShow = i;
+                        break;
+                    }
+                }
+            }
+        }
+        
+        if (nextStepToShow !== null) {
+            // Show the dependent step that should be displayed
+            console.log(`   🔄 Showing dependent step ${nextStepToShow} before returning to ${targetStep}`);
+            chatState.step = nextStepToShow;
         } else {
-            console.log(`   ⚠️ Invalid return step ${targetStep}, continuing normally`);
+            // No dependent steps to show, return to target
+            console.log(`   ⏭️ No dependent steps to show, returning directly 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';
+        });
+        console.log('  🙈 Hidden all range-wrappers');
+        
+        updateEditIcons();
+        await showNextStep();
+        return;
     }
 
     chatState.step++;
@@ -1930,6 +1984,42 @@ async function handleNext() {
 async function showNextStep() {
     const nextStep = flowData.flow[chatState.step];
 
+    // ✅ NEW: Check if step should be displayed based on condition
+    if (nextStep.shouldDisplay) {
+        let shouldShow = false;
+        
+        if (typeof nextStep.shouldDisplay === 'function') {
+            // Custom function
+            try {
+                shouldShow = await nextStep.shouldDisplay(chatState.data);
+                console.log(`  🔍 shouldDisplay function returned: ${shouldShow}`);
+            } catch (error) {
+                console.error('Error in shouldDisplay function:', error);
+                shouldShow = false;
+            }
+        } else if (typeof nextStep.shouldDisplay === 'boolean') {
+            // Simple boolean
+            shouldShow = nextStep.shouldDisplay;
+            console.log(`  🔍 shouldDisplay boolean: ${shouldShow}`);
+        }
+        
+        if (!shouldShow) {
+            console.log(`  ⏭️ Skipping step ${chatState.step} (shouldDisplay returned false)`);
+            chatState.step++;
+            
+            if (chatState.step >= flowData.flow.length) {
+                handleCompletion();
+                return;
+            }
+            
+            // Recursively check next step
+            await showNextStep();
+            return;
+        }
+        
+        console.log(`  ✅ Displaying step ${chatState.step} (shouldDisplay returned true)`);
+    }
+
     if (nextStep.onStart) {
         try {
             const canStart = await nextStep.onStart(chatState.data);
@@ -2264,7 +2354,32 @@ function editStep(stepNumber) {
     console.log(`   Clearing history from step ${stepNumber} forward...`);
     chatState.history = chatState.history.filter(h => h.step < stepNumber);
     
-    console.log(`   ✅ Keeping ALL data intact for editing (no data deleted)`);
+    // ✅ Find dependent steps (but don't clear anything)
+    const editedStepField = flowData.flow[stepNumber]?.input?.field;
+    console.log(`   🔗 Checking for steps dependent on: ${editedStepField}`);
+    
+    if (editedStepField) {
+        // Find all steps that depend on the edited step
+        const dependentSteps = [];
+        flowData.flow.forEach((step, index) => {
+            if (index > stepNumber && step.dependsOn) {
+                // Check if this step depends on the edited field
+                const dependencies = Array.isArray(step.dependsOn) ? step.dependsOn : [step.dependsOn];
+                
+                if (dependencies.includes(editedStepField)) {
+                    dependentSteps.push(index);
+                    console.log(`   🔗 Found dependent step ${index} (depends on ${editedStepField})`);
+                }
+            }
+        });
+        
+        if (dependentSteps.length > 0) {
+            console.log(`   ✅ ${dependentSteps.length} dependent steps will be re-shown after editing`);
+            console.log(`   ✅ All data, messages, and history kept intact`);
+        }
+    }
+    
+    console.log(`   ✅ Keeping ALL data, messages, and history intact for editing`);
     console.log(`   Current data:`, chatState.data);
 
     console.log(`   Calling goToStep(${stepNumber})...`);