Convert DOCX, EPUB, Markdown, and HTML to PDF in Node.js

import libre from "libreoffice-convert";
import { promisify } from "util";

const convertAsync = promisify(libre.convert);

async function officeToPdf(inputBuffer) {
  const pdfBuffer = await convertAsync(inputBuffer, ".pdf", undefined);
  return pdfBuffer;
}

import { exec } from "child_process";
import { promisify } from "util";
import { writeFile, readFile, unlink } from "fs/promises";
import { join } from "path";
import { tmpdir } from "os";
import { v4 as uuid } from "uuid";

const execAsync = promisify(exec);

async function ebookToPdf(inputBuffer, inputExtension) {
  const inputPath = join(tmpdir(), `${uuid()}${inputExtension}`);
  const outputPath = join(tmpdir(), `${uuid()}.pdf`);

  try {
    await writeFile(inputPath, inputBuffer);
    await execAsync(`ebook-convert "${inputPath}" "${outputPath}"`);
    return await readFile(outputPath);
  } finally {
    await unlink(inputPath).catch(() => {});
    await unlink(outputPath).catch(() => {});
  }
}

async function getMetadata(inputBuffer, mimeType) {
  const ext = mimeToExtension(mimeType); // e.g. ".epub", ".pdf".
  const inputPath = join(tmpdir(), `${uuid()}${ext}`);

  try {
    await writeFile(inputPath, inputBuffer);
    const { stdout } = await execAsync(`ebook-meta "${inputPath}"`);
    return parseMetadataOutput(stdout);
  } finally {
    await unlink(inputPath).catch(() => {});
  }
}

import { mdToPdf } from "md-to-pdf";

async function markdownToPdf(markdownBuffer) {
  const markdownString = markdownBuffer.toString("utf-8");
  const result = await mdToPdf({ content: markdownString });
  return result?.content; // PDF as `Buffer`.
}

import puppeteer from "puppeteer";

async function webPageToPdf(url) {
  const browser = await puppeteer.launch({ headless: true });
  const page = await browser.newPage();

  await page.goto(url, { waitUntil: "networkidle2" });

  const pdfBuffer = await page.pdf({
    format: "A4",
    printBackground: true,
    margin: {
      top: "20mm",
      right: "20mm",
      bottom: "20mm",
      left: "20mm",
    },
  });

  await browser.close();
  return pdfBuffer;
}

async function ocrPdf(pdfBuffer, language = "eng") {
  const inputPath = join(tmpdir(), `${uuid()}.pdf`);
  const outputPath = join(tmpdir(), `${uuid()}.pdf`);

  try {
    await writeFile(inputPath, pdfBuffer);
    await execAsync(
      `ocrmypdf -l ${language} --skip-text --output-type pdf -q "${inputPath}" "${outputPath}"`,
    );
    return await readFile(outputPath);
  } finally {
    await unlink(inputPath).catch(() => {});
    await unlink(outputPath).catch(() => {});
  }
}

async function processUpload(buffer, filename, mimeType) {
  let pdfBuffer;

  // Step 1: Convert to PDF if needed.
  if (mimeType === "application/pdf") {
    pdfBuffer = buffer;
  } else if (isOfficeFormat(mimeType)) {
    pdfBuffer = await officeToPdf(buffer);
  } else if (isEbookFormat(mimeType)) {
    pdfBuffer = await ebookToPdf(buffer, mimeToExtension(mimeType));
  } else if (mimeType === "text/markdown") {
    pdfBuffer = await markdownToPdf(buffer);
  }

  // Step 2: Check if OCR is needed.
  const { pages, needsOcr } = await checkPdf(pdfBuffer);

  // Step 3: Run OCR if needed.
  if (needsOcr) {
    pdfBuffer = await ocrPdf(pdfBuffer);
  }

  // Step 4: Generate preview thumbnail.
  const preview = await generatePreview(pdfBuffer);

  // Step 5: Extract text for indexing.
  const text = await extractText(pdfBuffer);

  return { pdfBuffer, preview, text, pages };
}

const instance = await NutrientViewer.load({
  container: "#pdf-container",
  document: "report.docx", // Word, Excel, and PowerPoint are all supported.
});

await instance.applyOperations([
  { type: "performOcr", language: "english", pageIndexes: "all" },
]);