🎨 Lesson 7.5: Advanced Form Patterns

🔗 Field Dependencies

Field dependencies occur when one field's value affects or determines another field's options, validation, or value. Common examples include country → state → city cascading dropdowns, or automatic calculations based on other fields.

Cascading Dropdowns

The classic example: selecting a country determines which states are available, and selecting a state determines which cities appear:

import { useEffect } from 'react';
import { useForm, useWatch } from 'react-hook-form';

interface LocationData {
  country: string;
  state: string;
  city: string;
}

// Mock data - in real app, this would come from an API
const locationData = {
  USA: {
    California: ['Los Angeles', 'San Francisco', 'San Diego'],
    Texas: ['Houston', 'Dallas', 'Austin'],
    NewYork: ['New York City', 'Buffalo', 'Rochester']
  },
  Canada: {
    Ontario: ['Toronto', 'Ottawa', 'Mississauga'],
    Quebec: ['Montreal', 'Quebec City', 'Laval'],
    BritishColumbia: ['Vancouver', 'Victoria', 'Surrey']
  }
};

const CascadingDropdowns: React.FC = () => {
  const { register, watch, setValue, resetField } = useForm<LocationData>({
    defaultValues: {
      country: '',
      state: '',
      city: ''
    }
  });

  const selectedCountry = watch('country');
  const selectedState = watch('state');

  // Get available states based on selected country
  const availableStates = selectedCountry 
    ? Object.keys(locationData[selectedCountry as keyof typeof locationData] || {})
    : [];

  // Get available cities based on selected state
  const availableCities = selectedCountry && selectedState
    ? locationData[selectedCountry as keyof typeof locationData]?.[selectedState] || []
    : [];

  // Reset dependent fields when parent changes
  useEffect(() => {
    if (selectedCountry) {
      // Country changed - reset state and city
      resetField('state');
      resetField('city');
    }
  }, [selectedCountry, resetField]);

  useEffect(() => {
    if (selectedState) {
      // State changed - reset city
      resetField('city');
    }
  }, [selectedState, resetField]);

  return (
    <form>
      <div className="form-group">
        <label htmlFor="country">Country *</label>
        <select id="country" {...register('country', { required: true })}>
          <option value="">Select a country</option>
          <option value="USA">United States</option>
          <option value="Canada">Canada</option>
        </select>
      </div>

      <div className="form-group">
        <label htmlFor="state">State/Province *</label>
        <select 
          id="state" 
          {...register('state', { required: true })}
          disabled={!selectedCountry}
        >
          <option value="">
            {selectedCountry ? 'Select a state' : 'Select a country first'}
          </option>
          {availableStates.map(state => (
            <option key={state} value={state}>
              {state}
            </option>
          ))}
        </select>
      </div>

      <div className="form-group">
        <label htmlFor="city">City *</label>
        <select 
          id="city" 
          {...register('city', { required: true })}
          disabled={!selectedState}
        >
          <option value="">
            {selectedState ? 'Select a city' : 'Select a state first'}
          </option>
          {availableCities.map(city => (
            <option key={city} value={city}>
              {city}
            </option>
          ))}
        </select>
      </div>
    </form>
  );
};

Loading Dependent Data from API

In real applications, dependent data often comes from an API:

const DynamicCascadingDropdowns: React.FC = () => {
  const { register, watch, resetField } = useForm<LocationData>();
  const [states, setStates] = useState<string[]>([]);
  const [cities, setCities] = useState<string[]>([]);
  const [loadingStates, setLoadingStates] = useState(false);
  const [loadingCities, setLoadingCities] = useState(false);

  const selectedCountry = watch('country');
  const selectedState = watch('state');

  // Load states when country changes
  useEffect(() => {
    if (!selectedCountry) {
      setStates([]);
      return;
    }

    const loadStates = async () => {
      setLoadingStates(true);
      try {
        const response = await fetch(`/api/states?country=${selectedCountry}`);
        const data = await response.json();
        setStates(data);
      } catch (error) {
        console.error('Failed to load states:', error);
        setStates([]);
      } finally {
        setLoadingStates(false);
      }
    };

    loadStates();
    resetField('state');
    setCities([]);
    resetField('city');
  }, [selectedCountry, resetField]);

  // Load cities when state changes
  useEffect(() => {
    if (!selectedState) {
      setCities([]);
      return;
    }

    const loadCities = async () => {
      setLoadingCities(true);
      try {
        const response = await fetch(
          `/api/cities?country=${selectedCountry}&state=${selectedState}`
        );
        const data = await response.json();
        setCities(data);
      } catch (error) {
        console.error('Failed to load cities:', error);
        setCities([]);
      } finally {
        setLoadingCities(false);
      }
    };

    loadCities();
    resetField('city');
  }, [selectedState, selectedCountry, resetField]);

  return (
    <form>
      <div className="form-group">
        <label htmlFor="country">Country *</label>
        <select id="country" {...register('country')}>
          <option value="">Select a country</option>
          <option value="USA">United States</option>
          <option value="Canada">Canada</option>
        </select>
      </div>

      <div className="form-group">
        <label htmlFor="state">State/Province *</label>
        <select 
          id="state" 
          {...register('state')}
          disabled={!selectedCountry || loadingStates}
        >
          <option value="">
            {loadingStates ? 'Loading...' : 'Select a state'}
          </option>
          {states.map(state => (
            <option key={state} value={state}>{state}</option>
          ))}
        </select>
      </div>

      <div className="form-group">
        <label htmlFor="city">City *</label>
        <select 
          id="city" 
          {...register('city')}
          disabled={!selectedState || loadingCities}
        >
          <option value="">
            {loadingCities ? 'Loading...' : 'Select a city'}
          </option>
          {cities.map(city => (
            <option key={city} value={city}>{city}</option>
          ))}
        </select>
      </div>
    </form>
  );
};

Calculated Fields

Some fields automatically calculate based on other fields:

interface InvoiceData {
  quantity: number;
  unitPrice: number;
  subtotal: number;
  taxRate: number;
  taxAmount: number;
  total: number;
  discount: number;
}

const CalculatedFieldsForm: React.FC = () => {
  const { register, watch, setValue } = useForm<InvoiceData>({
    defaultValues: {
      quantity: 1,
      unitPrice: 0,
      taxRate: 10, // 10%
      discount: 0
    }
  });

  const quantity = watch('quantity');
  const unitPrice = watch('unitPrice');
  const taxRate = watch('taxRate');
  const discount = watch('discount');

  // Calculate derived values
  useEffect(() => {
    const subtotal = quantity * unitPrice;
    const discountAmount = (subtotal * discount) / 100;
    const subtotalAfterDiscount = subtotal - discountAmount;
    const taxAmount = (subtotalAfterDiscount * taxRate) / 100;
    const total = subtotalAfterDiscount + taxAmount;

    setValue('subtotal', subtotal);
    setValue('taxAmount', taxAmount);
    setValue('total', total);
  }, [quantity, unitPrice, taxRate, discount, setValue]);

  return (
    <form>
      <div className="form-row">
        <div className="form-group">
          <label htmlFor="quantity">Quantity</label>
          <input
            id="quantity"
            type="number"
            min="1"
            {...register('quantity', { valueAsNumber: true })}
          />
        </div>

        <div className="form-group">
          <label htmlFor="unitPrice">Unit Price</label>
          <input
            id="unitPrice"
            type="number"
            min="0"
            step="0.01"
            {...register('unitPrice', { valueAsNumber: true })}
          />
        </div>
      </div>

      <div className="form-group">
        <label htmlFor="discount">Discount (%)</label>
        <input
          id="discount"
          type="number"
          min="0"
          max="100"
          {...register('discount', { valueAsNumber: true })}
        />
      </div>

      <div className="form-group">
        <label htmlFor="taxRate">Tax Rate (%)</label>
        <input
          id="taxRate"
          type="number"
          min="0"
          max="100"
          step="0.1"
          {...register('taxRate', { valueAsNumber: true })}
        />
      </div>

      {/* Read-only calculated fields */}
      <div className="calculated-fields">
        <div className="form-group">
          <label>Subtotal</label>
          <input
            {...register('subtotal')}
            readOnly
            className="calculated"
          />
        </div>

        <div className="form-group">
          <label>Tax Amount</label>
          <input
            {...register('taxAmount')}
            readOnly
            className="calculated"
          />
        </div>

        <div className="form-group">
          <label>Total</label>
          <input
            {...register('total')}
            readOnly
            className="calculated total"
          />
        </div>
      </div>
    </form>
  );
};

const formatCurrency = (value: number): string => {
  return new Intl.NumberFormat('en-US', {
    style: 'currency',
    currency: 'USD'
  }).format(value);
};

// Display formatted value
<div className="calculated-display">
  <span>Total: </span>
  <strong>{formatCurrency(watch('total'))}</strong>
</div>

Field Dependency Hook

Extract complex field dependency logic into a reusable hook:

interface DependencyConfig<T> {
  sourceField: keyof T;
  targetField: keyof T;
  calculate: (sourceValue: any) => any;
}

const useFieldDependency = <T extends Record<string, any>>(
  control: Control<T>,
  dependencies: DependencyConfig<T>[]
) => {
  const { setValue } = useFormContext<T>();

  dependencies.forEach(({ sourceField, targetField, calculate }) => {
    const sourceValue = useWatch({
      control,
      name: sourceField as string
    });

    useEffect(() => {
      if (sourceValue !== undefined) {
        const calculatedValue = calculate(sourceValue);
        setValue(targetField as string, calculatedValue);
      }
    }, [sourceValue, targetField, calculate, setValue]);
  });
};

// Usage
const FormWithDependencies: React.FC = () => {
  const { control } = useForm<InvoiceData>();

  useFieldDependency(control, [
    {
      sourceField: 'quantity',
      targetField: 'subtotal',
      calculate: (qty) => qty * watch('unitPrice')
    },
    // More dependencies...
  ]);

  return <form>{/* ... */}</form>;
};

💾 Auto-Save Implementation

Auto-save is a critical feature for long forms. It prevents data loss if users accidentally close the browser, lose connection, or navigate away. Let's implement robust auto-save functionality.

Basic Auto-Save to localStorage

import { useEffect } from 'react';
import { useForm } from 'react-hook-form';

const STORAGE_KEY = 'form-draft';
const AUTO_SAVE_DELAY = 2000; // 2 seconds

const AutoSaveForm: React.FC = () => {
  const { register, watch, reset } = useForm({
    defaultValues: () => {
      // Load saved data on mount
      const saved = localStorage.getItem(STORAGE_KEY);
      return saved ? JSON.parse(saved) : {};
    }
  });

  const formData = watch();

  // Auto-save to localStorage
  useEffect(() => {
    const timer = setTimeout(() => {
      localStorage.setItem(STORAGE_KEY, JSON.stringify(formData));
      console.log('Form auto-saved');
    }, AUTO_SAVE_DELAY);

    return () => clearTimeout(timer);
  }, [formData]);

  const handleSubmit = (data: any) => {
    console.log('Submitting:', data);
    // Clear saved draft on successful submit
    localStorage.removeItem(STORAGE_KEY);
  };

  const clearDraft = () => {
    localStorage.removeItem(STORAGE_KEY);
    reset({});
  };

  return (
    <form onSubmit={handleSubmit}>
      {/* Form fields */}
      
      <div className="form-actions">
        <button type="button" onClick={clearDraft}>
          Clear Draft
        </button>
        <button type="submit">
          Submit
        </button>
      </div>
    </form>
  );
};

Auto-Save with Visual Feedback

Show users when their work is being saved:

type SaveStatus = 'idle' | 'saving' | 'saved' | 'error';

const AutoSaveWithFeedback: React.FC = () => {
  const { register, watch, formState } = useForm();
  const [saveStatus, setSaveStatus] = useState<SaveStatus>('idle');
  const [lastSaved, setLastSaved] = useState<Date | null>(null);

  const formData = watch();

  useEffect(() => {
    if (formState.isDirty) {
      setSaveStatus('saving');

      const timer = setTimeout(() => {
        try {
          localStorage.setItem(STORAGE_KEY, JSON.stringify(formData));
          setSaveStatus('saved');
          setLastSaved(new Date());
          
          // Reset to idle after 2 seconds
          setTimeout(() => setSaveStatus('idle'), 2000);
        } catch (error) {
          console.error('Auto-save failed:', error);
          setSaveStatus('error');
        }
      }, AUTO_SAVE_DELAY);

      return () => clearTimeout(timer);
    }
  }, [formData, formState.isDirty]);

  const formatLastSaved = () => {
    if (!lastSaved) return '';
    const seconds = Math.floor((Date.now() - lastSaved.getTime()) / 1000);
    if (seconds < 60) return 'just now';
    if (seconds < 3600) return `${Math.floor(seconds / 60)} minutes ago`;
    return lastSaved.toLocaleTimeString();
  };

  return (
    <div>
      {/* Save status indicator */}
      <div className={`save-status ${saveStatus}`}>
        {saveStatus === 'saving' && (
          <span>💾 Saving...</span>
        )}
        {saveStatus === 'saved' && (
          <span>✓ Saved {formatLastSaved()}</span>
        )}
        {saveStatus === 'error' && (
          <span>⚠️ Failed to save</span>
        )}
      </div>

      <form>
        {/* Form fields */}
      </form>
    </div>
  );
};

Auto-Save Hook

Create a reusable auto-save hook:

interface UseAutoSaveOptions {
  key: string;
  delay?: number;
  onSave?: (data: any) => void | Promise<void>;
  onError?: (error: Error) => void;
}

const useAutoSave = <T extends Record<string, any>>(
  formData: T,
  options: UseAutoSaveOptions
) => {
  const { key, delay = 2000, onSave, onError } = options;
  const [status, setStatus] = useState<SaveStatus>('idle');
  const [lastSaved, setLastSaved] = useState<Date | null>(null);

  useEffect(() => {
    setStatus('saving');

    const timer = setTimeout(async () => {
      try {
        // Save to localStorage
        localStorage.setItem(key, JSON.stringify(formData));

        // Call custom save function if provided
        if (onSave) {
          await onSave(formData);
        }

        setStatus('saved');
        setLastSaved(new Date());

        // Reset to idle after showing "saved" message
        setTimeout(() => setStatus('idle'), 2000);
      } catch (error) {
        console.error('Auto-save failed:', error);
        setStatus('error');
        if (onError && error instanceof Error) {
          onError(error);
        }
      }
    }, delay);

    return () => clearTimeout(timer);
  }, [formData, key, delay, onSave, onError]);

  const clearSaved = () => {
    localStorage.removeItem(key);
    setStatus('idle');
    setLastSaved(null);
  };

  return { status, lastSaved, clearSaved };
};

// Usage
const FormWithAutoSaveHook: React.FC = () => {
  const { register, watch } = useForm();
  const formData = watch();

  const { status, lastSaved } = useAutoSave(formData, {
    key: 'my-form-draft',
    delay: 2000,
    onSave: async (data) => {
      // Optional: save to server
      await fetch('/api/drafts', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(data)
      });
    },
    onError: (error) => {
      console.error('Save failed:', error);
      alert('Failed to save draft');
    }
  });

  return (
    <div>
      <SaveStatusIndicator status={status} lastSaved={lastSaved} />
      <form>{/* Form fields */}</form>
    </div>
  );
};

Auto-Save to Server

For critical data, save to your server instead of (or in addition to) localStorage:

const useServerAutoSave = <T,>(
  formData: T,
  draftId: string | null,
  options: {
    delay?: number;
    endpoint?: string;
  } = {}
) => {
  const { delay = 3000, endpoint = '/api/drafts' } = options;
  const [status, setStatus] = useState<SaveStatus>('idle');
  const [savedDraftId, setSavedDraftId] = useState<string | null>(draftId);

  useEffect(() => {
    setStatus('saving');

    const timer = setTimeout(async () => {
      try {
        const url = savedDraftId 
          ? `${endpoint}/${savedDraftId}` 
          : endpoint;
        
        const method = savedDraftId ? 'PUT' : 'POST';

        const response = await fetch(url, {
          method,
          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify(formData)
        });

        if (!response.ok) {
          throw new Error('Server save failed');
        }

        const result = await response.json();
        
        // Save draft ID for future updates
        if (!savedDraftId && result.id) {
          setSavedDraftId(result.id);
        }

        setStatus('saved');
        setTimeout(() => setStatus('idle'), 2000);
      } catch (error) {
        console.error('Server auto-save failed:', error);
        setStatus('error');
      }
    }, delay);

    return () => clearTimeout(timer);
  }, [formData, savedDraftId, endpoint, delay]);

  return { status, draftId: savedDraftId };
};

⚡ Interactive: Auto-Save Debounce Timing

This visualization demonstrates how debouncing prevents excessive save operations. Type in the input field and watch how multiple rapid keystrokes get coalesced into a single save:

🧙 Form Wizards

A form wizard is a specialized multi-step form that guides users through a specific process with clear instructions at each step. Wizards are great for complex workflows like product configuration, account setup, or onboarding.

Wizard vs. Regular Multi-Step Form

Complete Wizard Implementation

interface WizardStep {
  id: string;
  title: string;
  description: string;
  component: React.ComponentType<StepComponentProps>;
  canSkip?: boolean;
  icon?: string;
}

interface WizardContextValue {
  currentStepIndex: number;
  steps: WizardStep[];
  formData: any;
  goToStep: (index: number) => void;
  nextStep: (data: any) => void;
  previousStep: () => void;
  canGoToStep: (index: number) => boolean;
  isFirstStep: boolean;
  isLastStep: boolean;
  completedSteps: Set<number>;
}

const WizardContext = createContext<WizardContextValue | null>(null);

export const useWizard = () => {
  const context = useContext(WizardContext);
  if (!context) {
    throw new Error('useWizard must be used within WizardProvider');
  }
  return context;
};

const WizardProvider: React.FC<{
  steps: WizardStep[];
  onComplete: (data: any) => void;
  children: React.ReactNode;
}> = ({ steps, onComplete, children }) => {
  const [currentStepIndex, setCurrentStepIndex] = useState(0);
  const [formData, setFormData] = useState<any>({});
  const [completedSteps, setCompletedSteps] = useState<Set<number>>(
    new Set()
  );

  const isFirstStep = currentStepIndex === 0;
  const isLastStep = currentStepIndex === steps.length - 1;

  const canGoToStep = (index: number): boolean => {
    // Can go to current step or any completed step
    if (index === currentStepIndex) return true;
    if (completedSteps.has(index)) return true;
    
    // Can go to next step if current is completed
    if (index === currentStepIndex + 1 && completedSteps.has(currentStepIndex)) {
      return true;
    }
    
    return false;
  };

  const goToStep = (index: number) => {
    if (canGoToStep(index)) {
      setCurrentStepIndex(index);
    }
  };

  const nextStep = (stepData: any) => {
    // Save step data
    const updatedFormData = { ...formData, ...stepData };
    setFormData(updatedFormData);

    // Mark current step as completed
    setCompletedSteps(prev => new Set([...prev, currentStepIndex]));

    if (isLastStep) {
      // Submit complete form
      onComplete(updatedFormData);
    } else {
      // Move to next step
      setCurrentStepIndex(prev => prev + 1);
    }
  };

  const previousStep = () => {
    if (!isFirstStep) {
      setCurrentStepIndex(prev => prev - 1);
    }
  };

  const value: WizardContextValue = {
    currentStepIndex,
    steps,
    formData,
    goToStep,
    nextStep,
    previousStep,
    canGoToStep,
    isFirstStep,
    isLastStep,
    completedSteps
  };

  return (
    <WizardContext.Provider value={value}>
      {children}
    </WizardContext.Provider>
  );
};

// Main Wizard Component
const Wizard: React.FC<{
  steps: WizardStep[];
  onComplete: (data: any) => void;
}> = ({ steps, onComplete }) => {
  return (
    <WizardProvider steps={steps} onComplete={onComplete}>
      <WizardContainer />
    </WizardProvider>
  );
};

const WizardContainer: React.FC = () => {
  const {
    currentStepIndex,
    steps,
    formData,
    completedSteps,
    goToStep,
    canGoToStep
  } = useWizard();

  const currentStep = steps[currentStepIndex];
  const StepComponent = currentStep.component;

  return (
    <div className="wizard-container">
      {/* Wizard Header */}
      <div className="wizard-header">
        <h1>Setup Wizard</h1>
        <p>Complete the steps below to finish setup</p>
      </div>

      {/* Step Progress */}
      <div className="wizard-progress">
        {steps.map((step, index) => (
          <button
            key={step.id}
            onClick={() => goToStep(index)}
            disabled={!canGoToStep(index)}
            className={`
              wizard-step
              ${index === currentStepIndex ? 'active' : ''}
              ${completedSteps.has(index) ? 'completed' : ''}
            `}
          >
            <div className="step-number">
              {completedSteps.has(index) ? '✓' : index + 1}
            </div>
            <div className="step-info">
              <div className="step-title">{step.title}</div>
              <div className="step-description">{step.description}</div>
            </div>
          </button>
        ))}
      </div>

      {/* Current Step Content */}
      <div className="wizard-content">
        <div className="step-header">
          {currentStep.icon && (
            <span className="step-icon">{currentStep.icon}</span>
          )}
          <h2>{currentStep.title}</h2>
          <p>{currentStep.description}</p>
        </div>

        <StepComponent defaultValues={formData} />
      </div>
    </div>
  );
};

Step Component Interface

interface StepComponentProps {
  defaultValues?: any;
}

// Example step component
const AccountSetupStep: React.FC<StepComponentProps> = ({ defaultValues }) => {
  const { nextStep, previousStep, isFirstStep } = useWizard();
  
  const {
    register,
    handleSubmit,
    formState: { errors }
  } = useForm({
    defaultValues
  });

  const onSubmit = (data: any) => {
    nextStep(data);
  };

  return (
    <form onSubmit={handleSubmit(onSubmit)}>
      {/* Form fields */}
      
      <div className="wizard-actions">
        {!isFirstStep && (
          <button type="button" onClick={previousStep}>
            ← Back
          </button>
        )}
        <button type="submit">
          Continue →
        </button>
      </div>
    </form>
  );
};

Wizard with Review Step

const ReviewStep: React.FC<StepComponentProps> = () => {
  const { formData, previousStep, nextStep, goToStep, steps } = useWizard();

  const handleSubmit = () => {
    nextStep({}); // Triggers onComplete in WizardProvider
  };

  return (
    <div className="review-step">
      <h2>Review Your Information</h2>
      <p>Please review your information before submitting.</p>

      {/* Display all collected data */}
      {steps.slice(0, -1).map((step, index) => {
        const stepData = formData[step.id] || {};
        const hasData = Object.keys(stepData).length > 0;

        if (!hasData) return null;

        return (
          <div key={step.id} className="review-section">
            <div className="review-section-header">
              <h3>{step.title}</h3>
              <button
                type="button"
                onClick={() => goToStep(index)}
                className="edit-button"
              >
                Edit
              </button>
            </div>

            <dl className="review-data">
              {Object.entries(stepData).map(([key, value]) => (
                <div key={key} className="review-item">
                  <dt>{formatFieldName(key)}</dt>
                  <dd>{String(value)}</dd>
                </div>
              ))}
            </dl>
          </div>
        );
      })}

      <div className="wizard-actions">
        <button type="button" onClick={previousStep}>
          ← Back
        </button>
        <button
          type="button"
          onClick={handleSubmit}
          className="btn-primary"
        >
          Submit
        </button>
      </div>
    </div>
  );
};

// Helper function
const formatFieldName = (key: string): string => {
  return key
    .replace(/([A-Z])/g, ' $1')
    .replace(/^./, (str) => str.toUpperCase())
    .trim();
};

/* Wizard container */
.wizard-container {
  max-width: 900px;
  margin: 0 auto;
  padding: 2rem;
}

/* Progress steps */
.wizard-progress {
  display: flex;
  gap: 1rem;
  margin: 2rem 0;
  overflow-x: auto;
}

.wizard-step {
  flex: 1;
  min-width: 200px;
  padding: 1rem;
  border: 2px solid #e0e0e0;
  border-radius: 8px;
  background: white;
  cursor: pointer;
  transition: all 0.3s ease;
}

.wizard-step.active {
  border-color: #667eea;
  background: #f0f4ff;
}

.wizard-step.completed {
  border-color: #4CAF50;
}

.wizard-step:disabled {
  opacity: 0.5;
  cursor: not-allowed;
}

/* Review step */
.review-section {
  border: 1px solid #e0e0e0;
  border-radius: 8px;
  padding: 1.5rem;
  margin-bottom: 1.5rem;
}

.review-section-header {
  display: flex;
  justify-content: space-between;
  align-items: center;
  margin-bottom: 1rem;
}

.review-data {
  display: grid;
  grid-template-columns: 150px 1fr;
  gap: 0.75rem;
}

.review-item dt {
  font-weight: 600;
  color: #666;
}

.review-item dd {
  margin: 0;
}