@hortonstudio/main 1.7.13 → 1.7.14

package/autoInit/form.js

@@ -1,32 +1,4 @@
 export function init() {
-  const config = {
-    selectors: {
-      form: 'form',
-      errorTemplate: '[data-hs-form="form-error"]',
-      requiredStep: '[data-hs-form="required-step"]',
-      nextButton: '[data-hs-form="next-button"]',
-      nextAnim: '[data-hs-form="next-anim"]',
-      finalAnim: '[data-hs-form="final-anim"]'
-    },
-    errorMessages: {
-      email: 'Please enter a valid email address',
-      tel: 'Please enter a valid phone number',
-      number: 'Please enter a valid number',
-      url: 'Please enter a valid URL',
-      text: 'This field is required',
-      textarea: 'This field is required',
-      select: 'Please select an option',
-      checkbox: 'Please check this box',
-      radio: 'Please select an option',
-      default: 'This field is required'
-    }
-  };
-
-  const activeErrors = new Map();
-  let errorTemplate = null;
-  let originalErrorTemplate = null;
-  let isValidating = false;
-
   // Simple Custom Select Component for Webflow
   (function() {
     'use strict';
@@ -43,7 +15,7 @@ export function init() {
       });
 
       const selectWrappers = document.querySelectorAll('[data-hs-form="select"]');
-      
+
       selectWrappers.forEach(wrapper => {
         initSingleSelect(wrapper);
       });
@@ -54,36 +26,36 @@ export function init() {
       // Find all required elements
       const realSelect = wrapper.querySelector('select');
       if (!realSelect) return;
-      
+
       const selectName = realSelect.getAttribute('name') || 'custom-select';
       const customList = wrapper.querySelector('[data-hs-form="select-list"]');
       const button = wrapper.querySelector('button') || wrapper.querySelector('[role="button"]');
-      
+
       if (!customList || !button) return;
-      
+
       // Get and clone the option template
       const optionTemplate = customList.firstElementChild;
       if (!optionTemplate) return;
-      
+
       const templateClone = optionTemplate.cloneNode(true);
       optionTemplate.remove();
-      
+
       // Build options from real select
       const realOptions = realSelect.querySelectorAll('option');
       realOptions.forEach((option, index) => {
         const optionElement = templateClone.cloneNode(true);
         const textSpan = optionElement.querySelector('span');
-        
+
         if (textSpan) {
           textSpan.textContent = option.textContent;
         }
-        
+
         // Add attributes
         optionElement.setAttribute('data-value', option.value);
         optionElement.setAttribute('role', 'option');
         optionElement.setAttribute('id', `${selectName}-option-${index}`);
         optionElement.setAttribute('tabindex', '-1');
-        
+
         // Set selected state if this option is selected
         if (option.selected) {
           optionElement.setAttribute('aria-selected', 'true');
@@ -95,22 +67,22 @@ export function init() {
         } else {
           optionElement.setAttribute('aria-selected', 'false');
         }
-        
+
         customList.appendChild(optionElement);
       });
-      
+
       // Add ARIA attributes
       customList.setAttribute('role', 'listbox');
       customList.setAttribute('id', `${selectName}-listbox`);
-      
+
       button.setAttribute('role', 'combobox');
       button.setAttribute('aria-haspopup', 'listbox');
       button.setAttribute('aria-controls', `${selectName}-listbox`);
       button.setAttribute('aria-expanded', 'false');
       button.setAttribute('id', `${selectName}-button`);
-      
+
       // Find and connect label if exists
-      const label = wrapper.querySelector('label') || 
+      const label = wrapper.querySelector('label') ||
                    document.querySelector(`label[for="${realSelect.id}"]`);
       if (label) {
         const labelId = label.id || `${selectName}-label`;
@@ -122,28 +94,28 @@ export function init() {
         label.setAttribute('for', realSelect.id);
         button.setAttribute('aria-labelledby', labelId);
       }
-      
+
       // Track state
       let currentIndex = -1;
       let isOpen = false;
-      
+
       // Update expanded state
       function updateExpandedState(expanded) {
         isOpen = expanded;
         button.setAttribute('aria-expanded', expanded.toString());
       }
-      
+
       // Focus option by index
       function focusOption(index) {
         const options = customList.querySelectorAll('[role="option"]');
         if (index < 0 || index >= options.length) return;
-        
+
         // Remove previous focus
         options.forEach(opt => {
           opt.classList.remove('focused');
           opt.setAttribute('tabindex', '-1');
         });
-        
+
         // Add new focus
         currentIndex = index;
         options[index].classList.add('focused');
@@ -151,32 +123,32 @@ export function init() {
         options[index].focus();
         button.setAttribute('aria-activedescendant', options[index].id);
       }
-      
+
       // Select option
       function selectOption(optionElement) {
         const value = optionElement.getAttribute('data-value');
         const text = optionElement.querySelector('span')?.textContent || optionElement.textContent;
-        
+
         // Update real select
         realSelect.value = value;
         realSelect.dispatchEvent(new Event('change', { bubbles: true }));
-        
+
         // Update button text
         const buttonText = button.querySelector('span') || button;
         if (buttonText.tagName === 'SPAN') {
           buttonText.textContent = text;
         }
-        
+
         // Update aria-selected
         customList.querySelectorAll('[role="option"]').forEach(opt => {
           opt.setAttribute('aria-selected', 'false');
         });
         optionElement.setAttribute('aria-selected', 'true');
-        
+
         // Click the button to close
         button.click();
       }
-      
+
       // Button keyboard events
       button.addEventListener('keydown', (e) => {
         switch(e.key) {
@@ -185,7 +157,7 @@ export function init() {
             e.preventDefault();
             button.click();
             break;
-            
+
           case 'ArrowDown':
             e.preventDefault();
             if (!isOpen) {
@@ -194,7 +166,7 @@ export function init() {
               focusOption(0);
             }
             break;
-            
+
           case 'ArrowUp':
             e.preventDefault();
             if (isOpen) {
@@ -202,7 +174,7 @@ export function init() {
               focusOption(options.length - 1);
             }
             break;
-            
+
           case 'Escape':
             if (isOpen) {
               e.preventDefault();
@@ -211,15 +183,15 @@ export function init() {
             break;
         }
       });
-      
+
       // Option keyboard events (delegated)
       customList.addEventListener('keydown', (e) => {
         const option = e.target.closest('[role="option"]');
         if (!option) return;
-        
+
         const options = Array.from(customList.querySelectorAll('[role="option"]'));
         const currentIdx = options.indexOf(option);
-        
+
         switch(e.key) {
           case 'ArrowDown':
             e.preventDefault();
@@ -227,7 +199,7 @@ export function init() {
               focusOption(currentIdx + 1);
             }
             break;
-            
+
           case 'ArrowUp':
             e.preventDefault();
             if (currentIdx === 0) {
@@ -237,13 +209,13 @@ export function init() {
               focusOption(currentIdx - 1);
             }
             break;
-            
+
           case 'Enter':
           case ' ':
             e.preventDefault();
             selectOption(option);
             break;
-            
+
           case 'Escape':
             e.preventDefault();
             button.click();
@@ -251,7 +223,7 @@ export function init() {
             break;
         }
       });
-      
+
       // Option click events
       customList.addEventListener('click', (e) => {
         const option = e.target.closest('[role="option"]');
@@ -259,18 +231,18 @@ export function init() {
           selectOption(option);
         }
       });
-      
+
       // Track open/close state
       const observer = new MutationObserver((mutations) => {
         mutations.forEach((mutation) => {
           if (mutation.type === 'attributes') {
             // Check if dropdown is visible
-            const isVisible = !customList.hidden && 
+            const isVisible = !customList.hidden &&
                             customList.style.display !== 'none' &&
                             !customList.classList.contains('hidden');
-            
+
             updateExpandedState(isVisible);
-            
+
             if (!isVisible) {
               currentIndex = -1;
               button.removeAttribute('aria-activedescendant');
@@ -282,13 +254,13 @@ export function init() {
           }
         });
       });
-      
+
       // Observe the custom list for visibility changes
       observer.observe(customList, {
         attributes: true,
         attributeFilter: ['hidden', 'style', 'class']
       });
-      
+
       // Sync with real select changes
       realSelect.addEventListener('change', () => {
         const selectedOption = realSelect.options[realSelect.selectedIndex];
@@ -301,7 +273,7 @@ export function init() {
             if (buttonText.tagName === 'SPAN') {
               buttonText.textContent = text;
             }
-            
+
             // Update aria-selected
             customList.querySelectorAll('[role="option"]').forEach(opt => {
               opt.setAttribute('aria-selected', 'false');
@@ -311,546 +283,17 @@ export function init() {
         }
       });
     }
-    
+
     // Initialize on DOM ready
     if (document.readyState === 'loading') {
       document.addEventListener('DOMContentLoaded', initCustomSelects);
     } else {
       initCustomSelects();
     }
-    
+
     // Reinitialize for dynamic content
     window.initCustomSelects = initCustomSelects;
   })();
 
-  const initializeForms = () => {
-    const forms = document.querySelectorAll(config.selectors.form);
-    forms.forEach(form => {
-      form.setAttribute('novalidate', '');
-      
-      // Completely disable all browser validation methods
-      form.checkValidity = () => true;
-      form.reportValidity = () => true;
-      
-      // Override all input validation as well
-      const inputs = form.querySelectorAll('input, textarea, select');
-      inputs.forEach(input => {
-        // Remove required attribute and store it
-        if (input.hasAttribute('required')) {
-          input.removeAttribute('required');
-          input.setAttribute('data-was-required', 'true');
-        }
-        
-        // Override validation methods
-        input.checkValidity = () => true;
-        input.reportValidity = () => true;
-        input.setCustomValidity = () => {};
-      });
-    });
-
-    errorTemplate = document.querySelector(config.selectors.errorTemplate);
-    if (!errorTemplate) {
-      console.warn('Form validation: Error template not found');
-    } else {
-      // Clone the template, clean it up, and remove original from DOM
-      originalErrorTemplate = errorTemplate.cloneNode(true);
-      
-      // Clean up the cloned template
-      originalErrorTemplate.removeAttribute('data-hs-form');
-      originalErrorTemplate.removeAttribute('style');
-      originalErrorTemplate.textContent = ''; // Clear any placeholder text
-      
-      // Remove the original template from the DOM
-      errorTemplate.remove();
-    }
-  };
-
-  const getErrorMessage = (input) => {
-    const inputType = input.type || input.tagName.toLowerCase();
-    const value = input.value.trim();
-    
-    // If field is empty and was required, return required message
-    if (input.hasAttribute('data-was-required') && !value) {
-      return config.errorMessages[inputType] || config.errorMessages.default;
-    }
-    
-    // For non-empty invalid fields, return type-specific messages
-    if (value) {
-      switch (inputType) {
-        case 'email':
-          return 'Please enter a valid email address';
-        case 'url':
-          return 'Please enter a valid URL';
-        case 'number':
-          if (input.hasAttribute('min') && parseFloat(value) < parseFloat(input.min)) {
-            return `Number must be at least ${input.min}`;
-          }
-          if (input.hasAttribute('max') && parseFloat(value) > parseFloat(input.max)) {
-            return `Number must be no more than ${input.max}`;
-          }
-          return 'Please enter a valid number';
-        case 'tel':
-          return 'Please enter a valid phone number';
-        default:
-          if (input.hasAttribute('minlength') && value.length < parseInt(input.minlength)) {
-            return `Must be at least ${input.minlength} characters`;
-          }
-          if (input.hasAttribute('maxlength') && value.length > parseInt(input.maxlength)) {
-            return `Must be no more than ${input.maxlength} characters`;
-          }
-          if (input.hasAttribute('pattern')) {
-            return 'Please match the required format';
-          }
-          return config.errorMessages[inputType] || config.errorMessages.default;
-      }
-    }
-    
-    return config.errorMessages[inputType] || config.errorMessages.default;
-  };
-
-  const createErrorElement = (message) => {
-    if (!originalErrorTemplate) return null;
-
-    const errorElement = originalErrorTemplate.cloneNode(true);
-    errorElement.textContent = message;
-    
-    return errorElement;
-  };
-
-  const positionError = (errorElement, input) => {
-    const inputRect = input.getBoundingClientRect();
-    const errorRect = errorElement.getBoundingClientRect();
-    
-    let top = inputRect.bottom + window.scrollY + 8;
-    let left = inputRect.left + window.scrollX + (inputRect.width / 2) - (errorRect.width / 2);
-    
-    // Check viewport boundaries
-    const viewportWidth = window.innerWidth;
-    const viewportHeight = window.innerHeight;
-    
-    // Adjust horizontal position
-    if (left < 10) {
-      left = 10;
-    } else if (left + errorRect.width > viewportWidth - 10) {
-      left = viewportWidth - errorRect.width - 10;
-    }
-    
-    // Adjust vertical position if error would be below viewport
-    if (inputRect.bottom + errorRect.height + 16 > viewportHeight) {
-      top = inputRect.top + window.scrollY - errorRect.height - 8;
-    }
-    
-    const finalTop = top - window.scrollY;
-    const finalLeft = left - window.scrollX;
-    
-    // Only set the minimal positioning styles needed
-    errorElement.style.position = 'fixed';
-    errorElement.style.top = `${finalTop}px`;
-    errorElement.style.left = `${finalLeft}px`;
-    errorElement.style.zIndex = '9999';
-  };
-
-  const showError = (input, message) => {
-    removeError(input);
-    
-    const errorElement = createErrorElement(message);
-    if (!errorElement) return;
-    document.body.appendChild(errorElement);
-    positionError(errorElement, input);
-    
-    activeErrors.set(input, errorElement);
-    
-    input.setAttribute('aria-invalid', 'true');
-    input.setAttribute('aria-describedby', `error-${Date.now()}`);
-    errorElement.id = input.getAttribute('aria-describedby');
-  };
-
-  const removeError = (input) => {
-    const errorElement = activeErrors.get(input);
-    if (errorElement) {
-      errorElement.remove();
-      activeErrors.delete(input);
-      input.removeAttribute('aria-invalid');
-      input.removeAttribute('aria-describedby');
-    }
-  };
-
-  const customValidateField = (field) => {
-    const value = field.value.trim();
-    const type = field.type || field.tagName.toLowerCase();
-
-    // Check if field was required (now stored in data-was-required)
-    if (field.hasAttribute('data-was-required')) {
-      // Special handling for checkboxes
-      if (type === 'checkbox') {
-        return field.checked;
-      }
-
-      // Special handling for radio buttons - check if ANY radio in the group is checked
-      if (type === 'radio') {
-        const radioName = field.getAttribute('name');
-        if (radioName) {
-          // Find all radios with the same name in the same form
-          const form = field.closest('form');
-          const radioGroup = form ?
-            form.querySelectorAll(`input[type="radio"][name="${radioName}"]`) :
-            document.querySelectorAll(`input[type="radio"][name="${radioName}"]`);
-
-          // Check if any radio in the group is checked
-          return Array.from(radioGroup).some(radio => radio.checked);
-        }
-        // Fallback to individual check if no name attribute
-        return field.checked;
-      }
-
-      // For other field types, check if empty
-      if (!value) {
-        return false;
-      }
-      
-      // Type-specific validation for non-empty values
-      switch (type) {
-        case 'email':
-          // Basic email validation
-          const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-          return emailRegex.test(value);
-          
-        case 'url':
-          // Basic URL validation
-          try {
-            new URL(value);
-            return true;
-          } catch {
-            return false;
-          }
-          
-        case 'number':
-          // Number validation
-          const num = parseFloat(value);
-          if (isNaN(num)) return false;
-          
-          // Check min/max if present
-          if (field.hasAttribute('min') && num < parseFloat(field.min)) return false;
-          if (field.hasAttribute('max') && num > parseFloat(field.max)) return false;
-          return true;
-          
-        case 'tel':
-          // Basic phone validation (at least 10 digits)
-          const phoneRegex = /\d{10,}/;
-          return phoneRegex.test(value.replace(/\D/g, ''));
-          
-        default:
-          // For text, textarea, etc. - check minlength/maxlength
-          if (field.hasAttribute('minlength') && value.length < parseInt(field.minlength)) return false;
-          if (field.hasAttribute('maxlength') && value.length > parseInt(field.maxlength)) return false;
-          
-          // Check pattern if present
-          if (field.hasAttribute('pattern')) {
-            const pattern = new RegExp(field.pattern);
-            return pattern.test(value);
-          }
-          
-          return true;
-      }
-    }
-    
-    return true; // Field is valid if not required or passes validation
-  };
-
-  const validateContainer = (container) => {
-    const requiredFields = container.querySelectorAll('input[data-was-required], textarea[data-was-required], select[data-was-required]');
-    let isValid = true;
-    let firstInvalidField = null;
-    const validatedRadioGroups = new Set(); // Track validated radio groups
-
-    requiredFields.forEach((field) => {
-      const type = field.type || field.tagName.toLowerCase();
-
-      // For radio buttons, only validate once per group
-      if (type === 'radio') {
-        const radioName = field.getAttribute('name');
-        if (radioName && validatedRadioGroups.has(radioName)) {
-          return; // Skip - already validated this radio group
-        }
-        if (radioName) {
-          validatedRadioGroups.add(radioName);
-        }
-      }
-
-      const fieldValid = customValidateField(field);
-
-      if (!fieldValid) {
-        isValid = false;
-
-        if (!firstInvalidField) {
-          firstInvalidField = field;
-        }
-      }
-    });
-
-    if (!isValid && firstInvalidField) {
-      activeErrors.forEach((_, input) => {
-        removeError(input);
-      });
-
-      firstInvalidField.focus();
-
-      const message = getErrorMessage(firstInvalidField);
-      showError(firstInvalidField, message);
-    }
-
-    return isValid;
-  };
-
-  // Helper function to parse comma-separated config values
-  const parseFormConfig = (configString) => {
-    if (!configString) return [];
-    return configString.split(',').map(config => config.trim());
-  };
-
-  const handleFormSubmit = (event) => {
-    const form = event.target;
-    
-    // Set validation flag to prevent click outside interference
-    isValidating = true;
-    
-    const isValid = validateContainer(form);
-    
-    // Reset validation flag after a brief delay
-    setTimeout(() => {
-      isValidating = false;
-    }, 200);
-    
-    if (!isValid) {
-      // Only prevent submission if form is invalid
-      event.preventDefault();
-      event.stopPropagation();
-      event.stopImmediatePropagation();
-      return false;
-    } else {
-      // Clear all errors before submission
-      activeErrors.forEach((_, input) => {
-        removeError(input);
-      });
-      
-      // Handle text replacement if this form has replace fields
-      const replaceFieldElements = form.querySelectorAll('input[data-hs-form^="replace-field-"], textarea[data-hs-form^="replace-field-"], select[data-hs-form^="replace-field-"]');
-      if (replaceFieldElements.length > 0) {
-        replaceFieldElements.forEach(field => {
-          const dataHsForm = field.getAttribute('data-hs-form');
-          const suffix = dataHsForm.replace('replace-field-', '');
-          const value = field.value;
-          
-          // Find all matching text elements
-          const textElements = document.querySelectorAll(`[data-hs-form="replace-text-${suffix}"]`);
-          
-          textElements.forEach(element => {
-            element.textContent = value;
-          });
-        });
-      }
-      
-      // Handle form configuration
-      const formWrapper = form.closest('[data-hs-form="wrapper"]');
-      let shouldPreventSubmit = false;
-      
-      if (formWrapper && formWrapper.hasAttribute('data-hs-config')) {
-        const configString = formWrapper.getAttribute('data-hs-config');
-        const configs = parseFormConfig(configString);
-        
-        // Check for prevent-submit config
-        if (configs.includes('prevent-submit')) {
-          shouldPreventSubmit = true;
-        }
-        
-        // Check for click-trigger configs
-        configs.forEach(config => {
-          if (config.startsWith('click-trigger-')) {
-            const trigger = document.querySelector(`[data-hs-form="trigger"][data-hs-config*="${config}"]`);
-            if (trigger) {
-              setTimeout(() => {
-                trigger.click();
-              }, 100);
-            }
-          }
-        });
-      }
-      
-      // Trigger final animation if it exists
-      const finalAnimElement = form.querySelector(config.selectors.finalAnim);
-      if (finalAnimElement) {
-        finalAnimElement.click();
-      }
-
-      // Prevent submission if configured to do so
-      if (shouldPreventSubmit) {
-        event.preventDefault();
-        event.stopPropagation();
-        event.stopImmediatePropagation();
-        return false;
-      }
-      
-      // Don't prevent default - let the form submit naturally with its action/method
-    }
-  };
-
-  const handleNextButtonClick = (event) => {
-    event.preventDefault();
-    
-    const button = event.target;
-    const requiredStepContainer = button.closest(config.selectors.requiredStep);
-    
-    if (!requiredStepContainer) {
-      return;
-    }
-    
-    // Set validation flag to prevent click outside interference
-    isValidating = true;
-    
-    const isValid = validateContainer(requiredStepContainer);
-    
-    // Reset validation flag after a brief delay
-    setTimeout(() => {
-      isValidating = false;
-    }, 200);
-    
-    if (isValid) {
-      const nextAnimElement = requiredStepContainer.querySelector(config.selectors.nextAnim);
-      if (nextAnimElement) {
-        nextAnimElement.click();
-      }
-    }
-  };
-
-  const handleInputChange = (event) => {
-    const input = event.target;
-    if (activeErrors.has(input)) {
-      removeError(input);
-    }
-  };
-
-  const handleClickOutside = (event) => {
-    const clickedElement = event.target;
-    
-    // Don't process click outside during validation
-    if (isValidating) {
-      return;
-    }
-    
-    // Don't remove errors if clicking on next button
-    if (clickedElement.closest(config.selectors.nextButton)) {
-      return;
-    }
-    
-    // Don't remove errors immediately after they're created
-    setTimeout(() => {
-      // Double check validation flag hasn't been set during timeout
-      if (isValidating) {
-        return;
-      }
-      
-      activeErrors.forEach((errorElement, input) => {
-        if (input !== clickedElement && !input.contains(clickedElement) && 
-            errorElement !== clickedElement && !errorElement.contains(clickedElement)) {
-          removeError(input);
-        }
-      });
-    }, 100); // Small delay to prevent immediate removal
-  };
-
-  const handleScroll = () => {
-    activeErrors.forEach((errorElement, input) => {
-      const inputRect = input.getBoundingClientRect();
-      const isVisible = inputRect.top >= 0 && inputRect.bottom <= window.innerHeight;
-      
-      if (isVisible) {
-        positionError(errorElement, input);
-      } else {
-        errorElement.style.display = 'none';
-      }
-    });
-  };
-
-  const handleResize = () => {
-    activeErrors.forEach((errorElement, input) => {
-      positionError(errorElement, input);
-    });
-  };
-
-  const setupEventListeners = () => {
-    // Global invalid event prevention - this catches ALL invalid events
-    document.addEventListener('invalid', (e) => {
-      e.preventDefault();
-      e.stopPropagation();
-      e.stopImmediatePropagation();
-      return false;
-    }, true);
-    
-    // Form submit listeners - use capture phase to ensure we catch it first
-    document.addEventListener('submit', handleFormSubmit, true);
-    
-    // Next button listeners
-    document.addEventListener('click', (event) => {
-      if (event.target.closest(config.selectors.nextButton)) {
-        handleNextButtonClick(event);
-      }
-    });
-    
-    // Input change listeners
-    document.addEventListener('input', handleInputChange);
-    
-    // Click outside listeners
-    document.addEventListener('click', handleClickOutside);
-    
-    // Scroll and resize listeners
-    window.addEventListener('scroll', handleScroll);
-    window.addEventListener('resize', handleResize);
-  };
-
-  const destroy = () => {
-    // Clean up all active errors
-    activeErrors.forEach((_, input) => {
-      removeError(input);
-    });
-    
-    // Remove event listeners
-    document.removeEventListener('invalid', (e) => {
-      e.preventDefault();
-      e.stopPropagation();
-      e.stopImmediatePropagation();
-      return false;
-    }, true);
-    document.removeEventListener('submit', handleFormSubmit, true);
-    document.removeEventListener('input', handleInputChange);
-    document.removeEventListener('click', handleClickOutside);
-    window.removeEventListener('scroll', handleScroll);
-    window.removeEventListener('resize', handleResize);
-  };
-
-
-  // Initialize the form validation system
-  const initializeFormValidation = () => {
-    try {
-      initializeForms();
-      setupEventListeners();
-      
-      return {
-        result: "form initialized",
-        destroy
-      };
-    } catch (error) {
-      console.error('Form validation initialization failed:', error);
-      return {
-        result: "form initialization failed",
-        destroy
-      };
-    }
-  };
-
-  // Handle DOM ready state
-  if (document.readyState === "loading") {
-    document.addEventListener("DOMContentLoaded", initializeFormValidation);
-  } else {
-    return initializeFormValidation();
-  }
-}
+  return { result: "form initialized" };
+}