/pdf-form-filler fill application form with customer data

/pdf-form-filler complete tax form with provided information

/pdf-form-filler populate contract form fields

/pdf-form-filler fill employee onboarding form with John Doe's information

/pdf-form-filler complete insurance application with all required fields

/pdf-form-filler fill multiple registration forms with customer data

async function fillPDFForm(pdfBytes, formData) {
  try {
    // Load PDF with compatibility options
    const pdfDoc = await PDFDocument.load(pdfBytes, {
      ignoreEncryption: true,
      updateMetadata: false
    });
    
    const form = pdfDoc.getForm();
    const fields = form.getFields();
    
    // Categorize fields by type
    const textFields = fields.filter(field => 
      field.constructor.name === 'PDFTextField');
    const checkBoxes = fields.filter(field => 
      field.constructor.name === 'PDFCheckBox');
    const dropdowns = fields.filter(field => 
      field.constructor.name === 'PDFDropdown');
    
    // Fill text fields with fallbacks
    for (const [name, value] of Object.entries(formData)) {
      try {
        // Direct field name match
        form.getTextField(name).setText(String(value));
      } catch (error) {
        // Find similar field name
        const similarField = textFields.find(f => 
          f.getName().toLowerCase().includes(name.toLowerCase()));
        
        if (similarField) {
          similarField.setText(String(value));
        }
      }
    }
    
    return await pdfDoc.save();
  } catch (error) {
    console.error(`Error filling form: ${error.message}`);
    throw error;
  }
}

// Handle checkboxes with multiple methods
for (const [name, value] of Object.entries(formData)) {
  if (!value || typeof value !== 'boolean' && value !== 'true') continue;
  
  for (const checkbox of checkBoxes) {
    if (checkbox.getName().toLowerCase().includes(name.toLowerCase())) {
      try {
        // Method 1: Standard check
        checkbox.check();
      } catch (e1) {
        // Method 2: Try different values
        const values = ['Yes', 'On', 'X', 'TRUE', '1', ''];
        for (const val of values) {
          try {
            checkbox.setValue(val);
            break;
          } catch (e2) {
            // Continue to next value
          }
        }
      }
    }
  }
}

// Handle dropdowns with value matching
for (const [name, value] of Object.entries(formData)) {
  const dropdown = dropdowns.find(d => 
    d.getName().toLowerCase().includes(name.toLowerCase()));
  
  if (dropdown) {
    const options = dropdown.getOptions();
    // Find exact or similar option
    const option = options.find(o => 
      o.toLowerCase() === String(value).toLowerCase() || 
      o.toLowerCase().includes(String(value).toLowerCase()));
    
    if (option) {
      dropdown.select(option);
    } else if (options.length > 0) {
      // Fallback to first option
      dropdown.select(options[0]);
    }
  }
}

// Exact field name match
{
  "firstName": "John",
  "lastName": "Doe",
  "email": "[email protected]"
}

// Flexible field name matching
{
  "name": "John Doe",      // Matches "full_name", "customer_name", etc.
  "phone": "555-1234",     // Matches "phone_number", "telephone", etc.
  "address": "123 Main St" // Matches "street_address", "mailing_address", etc.
}

// Checkbox handling
{
  "subscribe": true,       // Checks subscription checkbox
  "terms": "checked",      // Alternative checkbox value
  "newsletter": false      // Leaves checkbox unchecked
}

{
  message: 'PDF form filled successfully',
  fileName: 'filled_form.pdf',
  mimeType: 'application/pdf',
  pdf: base64EncodedPdf  // IMPORTANT: use 'pdf' as the key name
}

try {
  // Primary field filling method
  form.getTextField(fieldName).setText(value);
} catch (primaryError) {
  try {
    // Secondary method: similar name matching
    const field = findSimilarField(fieldName);
    field.setText(value);
  } catch (secondaryError) {
    // Log error but continue processing
    console.warn(`Could not fill field ${fieldName}: ${secondaryError.message}`);
  }
}

// Log all field information
fields.forEach(field => {
  console.log(`Field: "${field.getName()}" (${field.constructor.name})`);
  
  if (field.constructor.name === 'PDFDropdown') {
    console.log(`Options: ${field.getOptions().join(', ')}`);
  }
});

console.log(`Found ${fields.length} fields:`);
console.log(`- ${textFields.length} text fields`);
console.log(`- ${checkBoxes.length} checkboxes`);
console.log(`- ${dropdowns.length} dropdowns`);

/pdf-form-filler complete job application with candidate information

/pdf-form-filler fill tax return with financial data

/pdf-form-filler populate insurance claim form with incident details

/pdf-form-filler complete event registration with attendee information

// Custom handling for specific field types
const customHandlers = {
  date: (field, value) => {
    const formattedDate = new Date(value).toLocaleDateString();
    field.setText(formattedDate);
  },
  
  currency: (field, value) => {
    const formattedCurrency = `$${parseFloat(value).toFixed(2)}`;
    field.setText(formattedCurrency);
  }
};

// Process multiple forms with same data
async function fillMultipleForms(formPaths, commonData) {
  const results = [];
  
  for (const formPath of formPaths) {
    try {
      const pdfBytes = await readFile(formPath);
      const filledPdf = await fillPDFForm(pdfBytes, commonData);
      results.push({
        success: true,
        fileName: formPath,
        pdf: filledPdf
      });
    } catch (error) {
      results.push({
        success: false,
        fileName: formPath,
        error: error.message
      });
    }
  }
  
  return results;
}