SheetJS vs ExcelJS vs node-xlsx 2026: 20+ Formats vs Streaming

import * as XLSX from "xlsx"
import { readFileSync, writeFileSync } from "fs"

// Read an Excel file:
const workbook = XLSX.readFile("packages.xlsx")

// Get first sheet:
const sheetName = workbook.SheetNames[0]
const worksheet = workbook.Sheets[sheetName]

// Convert sheet to JSON (array of objects using first row as headers):
const data: PackageRow[] = XLSX.utils.sheet_to_json(worksheet, {
  header: 1,           // Return arrays (default is objects using header row)
  defval: null,        // Default value for empty cells
  blankrows: false,    // Skip blank rows
  raw: false,          // Return formatted strings instead of raw values
})

// Or with automatic header detection:
const objects: PackageData[] = XLSX.utils.sheet_to_json(worksheet, {
  defval: null,
  raw: true,           // Keep numbers as numbers, dates as numbers
})

// Get range of data:
const range = XLSX.utils.decode_range(worksheet["!ref"] ?? "A1")
console.log(`Rows: ${range.e.r + 1}, Cols: ${range.e.c + 1}`)

// Create from scratch:
const wb = XLSX.utils.book_new()

const packageData = [
  ["Package", "Weekly Downloads", "Version", "License"],
  ["react", 25000000, "18.2.0", "MIT"],
  ["vue", 7000000, "3.4.0", "MIT"],
  ["angular", 3500000, "17.0.0", "MIT"],
]

// From 2D array:
const ws = XLSX.utils.aoa_to_sheet(packageData)

// Or from array of objects (auto-generates headers):
const ws2 = XLSX.utils.json_to_sheet(packages, {
  header: ["name", "downloads", "version", "license"],
  skipHeader: false,  // Include header row
})

// Column widths:
ws["!cols"] = [
  { wch: 20 },  // Column A — 20 chars wide
  { wch: 18 },  // Column B
  { wch: 10 },  // Column C
  { wch: 10 },  // Column D
]

// Append sheet to workbook:
XLSX.utils.book_append_sheet(wb, ws, "Packages")

// Write to file:
XLSX.writeFile(wb, "output.xlsx")

// Or get as buffer for API response:
const buffer = XLSX.write(wb, { type: "buffer", bookType: "xlsx" })
// Buffer can be sent as HTTP response or uploaded to S3

import * as XLSX from "xlsx"

function downloadExcel(data: PackageData[], filename = "packages.xlsx") {
  const wb = XLSX.utils.book_new()
  const ws = XLSX.utils.json_to_sheet(data)
  XLSX.utils.book_append_sheet(wb, ws, "Data")

  // Download in browser:
  XLSX.writeFile(wb, filename)
  // Or: const blob = new Blob([XLSX.write(wb, { type: "array" })], { type: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" })
}

// Access individual cells:
const cell = worksheet["B2"]
console.log(cell.v)  // Raw value (number, string, boolean, Date)
console.log(cell.t)  // Type: "n"=number, "s"=string, "b"=boolean, "d"=date
console.log(cell.w)  // Formatted string (how it appears in Excel)
console.log(cell.f)  // Formula (if applicable)

// Modify a cell:
worksheet["B2"] = { t: "n", v: 25000000, z: "#,##0" }  // Number with comma format

// Add formula:
worksheet["E2"] = { t: "n", f: "=B2/C2" }

import ExcelJS from "exceljs"

// Create a workbook:
const workbook = new ExcelJS.Workbook()
workbook.creator = "PkgPulse"
workbook.created = new Date()

const worksheet = workbook.addWorksheet("Package Downloads", {
  pageSetup: { paperSize: 9, orientation: "landscape" },
  views: [{ state: "frozen", ySplit: 1 }],  // Freeze header row
})

// Define columns with widths and header styles:
worksheet.columns = [
  { header: "Package", key: "name", width: 20 },
  { header: "Downloads", key: "downloads", width: 18, style: { numFmt: "#,##0" } },
  { header: "Version", key: "version", width: 10 },
  { header: "License", key: "license", width: 10 },
  { header: "Updated", key: "updatedAt", width: 14, style: { numFmt: "yyyy-mm-dd" } },
]

// Style the header row:
const headerRow = worksheet.getRow(1)
headerRow.font = { bold: true, size: 12, color: { argb: "FFFFFFFF" } }
headerRow.fill = {
  type: "pattern",
  pattern: "solid",
  fgColor: { argb: "FF2D6A4F" },
}
headerRow.alignment = { vertical: "middle", horizontal: "center" }
headerRow.height = 25

// Add rows:
packages.forEach((pkg, index) => {
  const row = worksheet.addRow({
    name: pkg.name,
    downloads: pkg.downloads,
    version: pkg.version,
    license: pkg.license,
    updatedAt: new Date(pkg.updatedAt),
  })

  // Zebra striping:
  if (index % 2 === 0) {
    row.fill = { type: "pattern", pattern: "solid", fgColor: { argb: "FFF5F5F5" } }
  }

  // Conditional formatting: red if downloads < 1000/week:
  if (pkg.downloads < 1000) {
    row.getCell("downloads").font = { color: { argb: "FFFF0000" }, bold: true }
  }
})

// Add auto-filter:
worksheet.autoFilter = { from: "A1", to: "E1" }

// Add a totals row:
worksheet.addRow([])  // Blank row
const totalRow = worksheet.addRow({
  name: "TOTAL",
  downloads: { formula: `SUM(B2:B${packages.length + 1})` },
})
totalRow.font = { bold: true }

// Write to file:
await workbook.xlsx.writeFile("packages-report.xlsx")

// Or write to buffer:
const buffer = await workbook.xlsx.writeBuffer()

import ExcelJS from "exceljs"
import { createReadStream, createWriteStream } from "fs"

// Stream reading (low memory):
async function* streamReadExcel(filepath: string) {
  const workbook = new ExcelJS.Workbook()
  const stream = createReadStream(filepath)

  await workbook.xlsx.read(stream)

  const worksheet = workbook.worksheets[0]
  worksheet.eachRow({ includeEmpty: false }, (row, rowNumber) => {
    if (rowNumber > 1) {  // Skip header
      yield row.values
    }
  })
}

// Stream writing (doesn't hold entire workbook in memory):
const workbookWriter = new ExcelJS.stream.xlsx.WorkbookWriter({
  filename: "large-output.xlsx",
  useStyles: true,
})

const worksheetWriter = workbookWriter.addWorksheet("data")
worksheetWriter.columns = [{ header: "Name", key: "name" }, { header: "Value", key: "value" }]

for await (const record of largeDataSource) {
  worksheetWriter.addRow(record).commit()  // Commit each row to disk immediately
}

await worksheetWriter.commit()
await workbookWriter.commit()

import xlsx from "node-xlsx"
import { readFileSync, writeFileSync } from "fs"

// Parse:
const workSheetsFromFile = xlsx.parse(readFileSync("packages.xlsx"))

const firstSheet = workSheetsFromFile[0]
console.log(firstSheet.name)  // "Sheet1"
console.log(firstSheet.data)  // 2D array: [[header1, header2], [val1, val2], ...]

// Build and write:
const data = [
  ["Package", "Downloads", "Version"],
  ["react", 25000000, "18.2.0"],
  ["vue", 7000000, "3.4.0"],
]

const buffer = xlsx.build([{ name: "Packages", data }])
writeFileSync("output.xlsx", buffer)

// Next.js: Parse uploaded Excel file and return JSON
// app/api/upload/route.ts
import { NextRequest, NextResponse } from "next/server"
import * as XLSX from "xlsx"

export async function POST(req: NextRequest) {
  const formData = await req.formData()
  const file = formData.get("file") as File

  if (!file) return NextResponse.json({ error: "No file" }, { status: 400 })

  // File size check before processing
  if (file.size > 10 * 1024 * 1024) {
    return NextResponse.json({ error: "File exceeds 10MB limit" }, { status: 400 })
  }

  const buffer = await file.arrayBuffer()
  const workbook = XLSX.read(buffer, { type: "buffer", cellDates: true })

  const sheetName = workbook.SheetNames[0]
  const rows = XLSX.utils.sheet_to_json(workbook.Sheets[sheetName], {
    defval: null,
    raw: false,
  })

  return NextResponse.json({ rows, count: rows.length })
}

// ExcelJS: Generate formatted Excel report as API response
export async function GET(req: NextRequest) {
  const workbook = new ExcelJS.Workbook()
  const ws = workbook.addWorksheet("Report")

  ws.columns = [
    { header: "Date", key: "date", width: 12 },
    { header: "Revenue", key: "revenue", width: 14, style: { numFmt: '"$"#,##0.00' } },
    { header: "Users", key: "users", width: 10 },
  ]

  // Style header
  ws.getRow(1).font = { bold: true }
  ws.getRow(1).fill = { type: "pattern", pattern: "solid", fgColor: { argb: "FF3B82F6" } }

  // Add data rows
  const data = await fetchReportData()
  data.forEach(row => ws.addRow(row))

  const buffer = await workbook.xlsx.writeBuffer()

  return new Response(buffer, {
    headers: {
      "Content-Type": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
      "Content-Disposition": 'attachment; filename="report.xlsx"',
    },
  })
}

interface PackageRow {
  name: string
  version: string
  downloads: number
}

const rows = XLSX.utils.sheet_to_json<PackageRow>(worksheet)
// rows is PackageRow[] — typed correctly

for await (const row of worksheet) {
  const nameCell: ExcelJS.Cell = row.getCell("A")
  const value: ExcelJS.CellValue = nameCell.value  // string | number | Date | null
}