lisichatbot 1.4.9 → 1.5.1

package/package.json

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

package/src/index.js

@@ -198,6 +198,13 @@ function updateEditIcons() {
             const stepData = flowData.flow[stepNumber];
             const hasInput = stepData && !!stepData.input;
             
+            // ✅ NEW: Check if edit is disabled for this step
+            if (stepData && stepData.disableEdit === true) {
+                editIcon.style.setProperty('display', 'none', 'important');
+                console.log(`  🚫 Step ${stepNumber}: Icon HIDDEN (edit disabled)`);
+                return;
+            }
+            
             if (chatState.completed) {
                 editIcon.style.setProperty('display', 'none', 'important');
                 console.log(`  🏁 Step ${stepNumber}: Icon HIDDEN (flow completed)`);
@@ -1214,6 +1221,23 @@ function handleCustomSelectClick(element, field, customConfig) {
         chatState.currentSelection = { field, value, name: optionName };
         console.log('  ✅ Regular option selected:', value);
         enableNextButton();
+        
+        // ✅ NEW: Check if auto-advance is enabled for regular options (not custom)
+        const currentStep = flowData.flow[chatState.step];
+        if (currentStep.autoAdvance === true) {
+            console.log('  ⚡ Auto-advance enabled - proceeding to next step');
+            
+            // Add a small delay for visual feedback
+            const delay = currentStep.autoAdvanceDelay || 500;
+            console.log(`  ⏱️ Waiting ${delay}ms before advancing`);
+            
+            setTimeout(() => {
+                if (elements.nextBtn && !elements.nextBtn.disabled) {
+                    console.log('  ▶️ Auto-advancing to next step');
+                    handleNext();
+                }
+            }, delay);
+        }
     }
 }
 
@@ -1647,6 +1671,23 @@ function handleOptionClick(element, field, isSingleSelect, options) {
             chatState.currentSelection = { field, value, name: optionName };
             
             enableNextButton();
+            
+            // ✅ NEW: Check if auto-advance is enabled
+            const currentStep = flowData.flow[chatState.step];
+            if (currentStep.autoAdvance === true) {
+                console.log('  ⚡ Auto-advance enabled - proceeding to next step');
+                
+                // Add a small delay for visual feedback
+                const delay = currentStep.autoAdvanceDelay || 500;
+                console.log(`  ⏱️ Waiting ${delay}ms before advancing`);
+                
+                setTimeout(() => {
+                    if (elements.nextBtn && !elements.nextBtn.disabled) {
+                        console.log('  ▶️ Auto-advancing to next step');
+                        handleNext();
+                    }
+                }, delay);
+            }
         }
 
     } else {
@@ -1842,11 +1883,113 @@ async function handleNext() {
     if (currentStep.onNext) {
         try {
             disableNextButton();
-            const canProceed = await currentStep.onNext(
+            const result = await currentStep.onNext(
                 chatState.currentSelection ? chatState.currentSelection.value : null,
                 chatState.data
             );
             
+            // ✅ NEW: Check if onNext wants to display a message in chat
+            if (result && typeof result === 'object' && result.showMessage) {
+                console.log('💬 onNext displaying message:', result.showMessage);
+                addMessage(result.showMessage, 'bot', false, null);
+                scrollToBottom();
+            }
+            
+            // ✅ NEW: Check if onNext returned data to update next step
+            if (result && typeof result === 'object' && result.updateNextStep) {
+                console.log('📝 onNext returned data to update next step:', result);
+                
+                const nextStepIndex = chatState.step + 1;
+                if (nextStepIndex < flowData.flow.length) {
+                    const nextStep = flowData.flow[nextStepIndex];
+                    
+                    // ✅ NEW: Support for updating specific input by field name
+                    // Example: { updateNextStep: true, fuel: { options: [...] } }
+                    if (nextStep.input && nextStep.input.field) {
+                        const inputFieldName = nextStep.input.field;
+                        
+                        // Check if result has a property matching the input field name
+                        if (result[inputFieldName]) {
+                            console.log(`   ✅ Updating input properties for field "${inputFieldName}":`, result[inputFieldName]);
+                            
+                            // Update nested properties
+                            if (result[inputFieldName].options !== undefined) {
+                                nextStep.input.options = result[inputFieldName].options;
+                                console.log(`      → input.options updated with ${result[inputFieldName].options.length} items`);
+                            }
+                            
+                            // Can also update other input properties
+                            if (result[inputFieldName].field !== undefined) {
+                                nextStep.input.field = result[inputFieldName].field;
+                                console.log(`      → input.field updated to: ${result[inputFieldName].field}`);
+                            }
+                            
+                            if (result[inputFieldName].selectedInputValueType !== undefined) {
+                                nextStep.input.selectedInputValueType = result[inputFieldName].selectedInputValueType;
+                            }
+                            
+                            if (result[inputFieldName].selectedInputPrefix !== undefined) {
+                                nextStep.input.selectedInputPrefix = result[inputFieldName].selectedInputPrefix;
+                            }
+                            
+                            if (result[inputFieldName].selectedInputSuffix !== undefined) {
+                                nextStep.input.selectedInputSuffix = result[inputFieldName].selectedInputSuffix;
+                            }
+                            
+                            if (result[inputFieldName].custom !== undefined) {
+                                nextStep.input.custom = result[inputFieldName].custom;
+                            }
+                            
+                            if (result[inputFieldName].min !== undefined) {
+                                nextStep.input.min = result[inputFieldName].min;
+                            }
+                            
+                            if (result[inputFieldName].max !== undefined) {
+                                nextStep.input.max = result[inputFieldName].max;
+                            }
+                        }
+                    }
+                    
+                    // ✅ LEGACY: Direct properties (backwards compatible)
+                    // Update options if provided
+                    if (result.options && nextStep.input) {
+                        console.log(`   ✅ Updating step ${nextStepIndex} input.options (direct):`, result.options);
+                        nextStep.input.options = result.options;
+                    }
+                    
+                    // ✅ Update field name if provided
+                    if (result.field && nextStep.input) {
+                        console.log(`   ✅ Updating step ${nextStepIndex} field name: ${result.field}`);
+                        nextStep.input.field = result.field;
+                    }
+                    
+                    // Update any other step properties if provided
+                    if (result.message) {
+                        console.log(`   ✅ Updating step ${nextStepIndex} message:`, result.message);
+                        nextStep.message = result.message;
+                    }
+                    
+                    if (result.inputType) {
+                        console.log(`   ✅ Updating step ${nextStepIndex} inputType:`, result.inputType);
+                        nextStep.inputType = result.inputType;
+                    }
+                    
+                    if (result.shouldDisplay !== undefined) {
+                        console.log(`   ✅ Updating step ${nextStepIndex} shouldDisplay`);
+                        nextStep.shouldDisplay = result.shouldDisplay;
+                    }
+                    
+                    if (result.dependsOn !== undefined) {
+                        console.log(`   ✅ Updating step ${nextStepIndex} dependsOn:`, result.dependsOn);
+                        nextStep.dependsOn = result.dependsOn;
+                    }
+                }
+            }
+            
+            // Check if onNext returned false to block progression
+            const canProceed = result === undefined || result === true || 
+                              (typeof result === 'object' && result.canProceed !== false);
+            
             if (!canProceed) {
                 enableNextButton();
                 return;
@@ -2037,9 +2180,130 @@ async function showNextStep() {
 
     if (nextStep.onStart) {
         try {
-            const canStart = await nextStep.onStart(chatState.data);
+            const result = await nextStep.onStart(chatState.data);
+            
+            // ✅ NEW: Check if onStart returned data to update current step
+            if (result && typeof result === 'object' && result.updateCurrentStep) {
+                console.log('📝 onStart returned data to update current step:', result);
+                
+                const currentStepIndex = chatState.step;
+                const currentStep = flowData.flow[currentStepIndex];
+                
+                // ✅ Support for updating specific input by field name
+                if (currentStep.input && currentStep.input.field) {
+                    const inputFieldName = currentStep.input.field;
+                    
+                    // Check if result has a property matching the input field name
+                    if (result[inputFieldName]) {
+                        console.log(`   ✅ Updating current step input.${inputFieldName}:`, result[inputFieldName]);
+                        
+                        // Update nested properties
+                        if (result[inputFieldName].options !== undefined) {
+                            currentStep.input.options = result[inputFieldName].options;
+                            console.log(`      → input.options updated with ${result[inputFieldName].options.length} items`);
+                        }
+                        
+                        if (result[inputFieldName].field !== undefined) {
+                            currentStep.input.field = result[inputFieldName].field;
+                        }
+                        
+                        if (result[inputFieldName].selectedInputValueType !== undefined) {
+                            currentStep.input.selectedInputValueType = result[inputFieldName].selectedInputValueType;
+                        }
+                        
+                        if (result[inputFieldName].selectedInputPrefix !== undefined) {
+                            currentStep.input.selectedInputPrefix = result[inputFieldName].selectedInputPrefix;
+                        }
+                        
+                        if (result[inputFieldName].selectedInputSuffix !== undefined) {
+                            currentStep.input.selectedInputSuffix = result[inputFieldName].selectedInputSuffix;
+                        }
+                        
+                        if (result[inputFieldName].custom !== undefined) {
+                            currentStep.input.custom = result[inputFieldName].custom;
+                        }
+                        
+                        if (result[inputFieldName].min !== undefined) {
+                            currentStep.input.min = result[inputFieldName].min;
+                        }
+                        
+                        if (result[inputFieldName].max !== undefined) {
+                            currentStep.input.max = result[inputFieldName].max;
+                        }
+                    }
+                }
+                
+                // ✅ Direct properties (backwards compatible)
+                if (result.options && currentStep.input) {
+                    console.log(`   ✅ Updating current step input.options (direct):`, result.options);
+                    currentStep.input.options = result.options;
+                }
+                
+                if (result.field && currentStep.input) {
+                    console.log(`   ✅ Updating current step field name: ${result.field}`);
+                    currentStep.input.field = result.field;
+                }
+                
+                // Update step-level properties
+                if (result.message) {
+                    console.log(`   ✅ Updating current step message:`, result.message);
+                    currentStep.message = result.message;
+                }
+                
+                if (result.inputType) {
+                    console.log(`   ✅ Updating current step inputType:`, result.inputType);
+                    currentStep.inputType = result.inputType;
+                }
+                
+                if (result.shouldDisplay !== undefined) {
+                    console.log(`   ✅ Updating current step shouldDisplay`);
+                    currentStep.shouldDisplay = result.shouldDisplay;
+                }
+                
+                if (result.dependsOn !== undefined) {
+                    console.log(`   ✅ Updating current step dependsOn:`, result.dependsOn);
+                    currentStep.dependsOn = result.dependsOn;
+                }
+                
+                if (result.autoAdvance !== undefined) {
+                    console.log(`   ✅ Updating current step autoAdvance:`, result.autoAdvance);
+                    currentStep.autoAdvance = result.autoAdvance;
+                }
+                
+                if (result.autoAdvanceDelay !== undefined) {
+                    console.log(`   ✅ Updating current step autoAdvanceDelay:`, result.autoAdvanceDelay);
+                    currentStep.autoAdvanceDelay = result.autoAdvanceDelay;
+                }
+            }
+            
+            // ✅ NEW: Check if onStart wants to display a message in chat
+            if (result && typeof result === 'object' && result.showMessage) {
+                console.log('💬 onStart displaying message:', result.showMessage);
+                addMessage(result.showMessage, 'bot', false, null);
+                scrollToBottom();
+            }
+            
+            // ✅ NEW: Check if onStart wants to block this step and skip to next
+            if (result && typeof result === 'object' && result.blockStep === true) {
+                console.log('⏭️ Step blocked by onStart - skipping to next step');
+                chatState.step++;
+                
+                if (chatState.step >= flowData.flow.length) {
+                    handleCompletion();
+                    return;
+                }
+                
+                // Recursively show next step
+                await showNextStep();
+                return;
+            }
+            
+            // Check if onStart blocked the step (old behavior - stops flow)
+            const canStart = result === undefined || result === true || 
+                           (typeof result === 'object' && result.canStart !== false);
+            
             if (!canStart) {
-                console.log('Step blocked');
+                console.log('❌ Step blocked by onStart - flow stopped');
                 return;
             }
         } catch (error) {