Document Generation

Goal

Create professional documents in different formats: PDF, DOCX, XLSX, PPTX.

Supported formats

Instructions per format

PDF - Generation from HTML/Markdown

# Option 1: Puppeteer (Node.js)
npm install puppeteer

# Option 2: wkhtmltopdf (CLI)
wkhtmltopdf input.html output.pdf

# Option 3: markdown-pdf (Markdown -> PDF)
npm install markdown-pdf

// Puppeteer - HTML to PDF
import puppeteer from 'puppeteer';

async function generatePDF(htmlContent: string, outputPath: string) {
  const browser = await puppeteer.launch();
  const page = await browser.newPage();
  await page.setContent(htmlContent, { waitUntil: 'networkidle0' });
  await page.pdf({
    path: outputPath,
    format: 'A4',
    margin: { top: '20mm', right: '15mm', bottom: '20mm', left: '15mm' },
    printBackground: true,
  });
  await browser.close();
}

DOCX - Word documents

// npm install docx
import { Document, Packer, Paragraph, TextRun, HeadingLevel } from 'docx';
import * as fs from 'fs';

async function generateDOCX(title: string, sections: Section[]) {
  const doc = new Document({
    sections: [{
      properties: {},
      children: [
        new Paragraph({
          text: title,
          heading: HeadingLevel.TITLE,
        }),
        ...sections.flatMap(section => [
          new Paragraph({
            text: section.heading,
            heading: HeadingLevel.HEADING_1,
          }),
          new Paragraph({
            children: [new TextRun(section.content)],
          }),
        ]),
      ],
    }],
  });

  const buffer = await Packer.toBuffer(doc);
  fs.writeFileSync('output.docx', buffer);
}

XLSX - Spreadsheets

// npm install exceljs
import ExcelJS from 'exceljs';

async function generateXLSX(data: Record<string, any>[]) {
  const workbook = new ExcelJS.Workbook();
  const sheet = workbook.addWorksheet('Data');

  // Headers from the keys of the first object
  const headers = Object.keys(data[0]);
  sheet.addRow(headers);

  // Header styling
  sheet.getRow(1).font = { bold: true };
  sheet.getRow(1).fill = {
    type: 'pattern',
    pattern: 'solid',
    fgColor: { argb: 'FF4472C4' },
  };

  // Data
  data.forEach(row => {
    sheet.addRow(headers.map(h => row[h]));
  });

  // Auto-width
  sheet.columns.forEach(col => {
    col.width = 15;
  });

  await workbook.xlsx.writeFile('output.xlsx');
}

PPTX - Presentations

// npm install pptxgenjs
import PptxGenJS from 'pptxgenjs';

function generatePPTX(slides: SlideData[]) {
  const pptx = new PptxGenJS();

  slides.forEach(slideData => {
    const slide = pptx.addSlide();

    // Title
    slide.addText(slideData.title, {
      x: 0.5, y: 0.5, w: 9, h: 1,
      fontSize: 28, bold: true, color: '363636',
    });

    // Content
    slide.addText(slideData.content, {
      x: 0.5, y: 1.8, w: 9, h: 4,
      fontSize: 16, color: '666666',
      bullet: slideData.bullets ? true: false,
    });
  });

  pptx.writeFile({ fileName: 'output.pptx' });
}

Python alternatives

# PDF with reportlab
pip install reportlab

# DOCX with python-docx
pip install python-docx

# XLSX with openpyxl
pip install openpyxl

# PPTX with python-pptx
pip install python-pptx

Generation workflow

1. IDENTIFY the required format (PDF, DOCX, XLSX, PPTX)
        |
2. PREPARE the data and content
        |
3. CHOOSE the library suited to the runtime (Node.js or Python)
        |
4. GENERATE the document with professional formatting
        |
5. VALIDATE the output (opening, layout, data)

Best practices

• Always use templates for visual consistency
• Separate data from formatting
• Handle encoding errors (UTF-8)
• Test with different data sizes
• Include metadata (author, date, subject)

Rules

• ALWAYS ask for the desired format if not specified
• ALWAYS verify that dependencies are installed before generating
• NEVER hardcode file paths
• PREFER reusable templates over one-shot documents