bentopdf-sh 0.1.0

package/src/engines/libreoffice.js

@@ -0,0 +1,43 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { createRequire } from "node:module";
+import { Engine } from "./base.js";
+
+const SUPPORTED = ["docx", "doc", "pptx", "ppt", "xlsx", "xls", "odt", "ods", "odp", "rtf"];
+
+export class LibreOfficeEngine extends Engine {
+  constructor() {
+    super("libreoffice");
+    this._converter = null;
+  }
+
+  supportedExtensions() {
+    return SUPPORTED;
+  }
+
+  async ensureLoaded() {
+    if (this._loaded) return;
+
+    const { LibreOfficeConverter } = await import("@matbee/libreoffice-converter/server");
+    const require = createRequire(import.meta.url);
+    const wasmLoader = require("@matbee/libreoffice-converter/wasm/loader");
+
+    this._converter = new LibreOfficeConverter({ wasmLoader });
+    await this._converter.initialize();
+    this._loaded = true;
+  }
+
+  async convert(inputPath, outputPath, options = {}) {
+    await this.ensureLoaded();
+
+    const ext = path.extname(inputPath).slice(1).toLowerCase();
+    const inputData = fs.readFileSync(inputPath);
+
+    const result = await this._converter.convert(inputData, {
+      outputFormat: "pdf",
+      inputFormat: ext,
+    });
+
+    fs.writeFileSync(outputPath, Buffer.from(result.data));
+  }
+}

package/src/engines/mupdf.js

@@ -0,0 +1,73 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { Engine } from "./base.js";
+
+const SUPPORTED = ["jpg", "jpeg", "png", "svg", "tiff", "tif", "webp"];
+
+const MIME_MAP = {
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  png: "image/png",
+  svg: "image/svg+xml",
+  tiff: "image/tiff",
+  tif: "image/tiff",
+  webp: "image/webp",
+  html: "text/html",
+  htm: "text/html",
+};
+
+export class MuPdfEngine extends Engine {
+  constructor() {
+    super("mupdf");
+    this._mupdf = null;
+  }
+
+  supportedExtensions() {
+    return SUPPORTED;
+  }
+
+  async ensureLoaded() {
+    if (this._loaded) return;
+    this._mupdf = await import("mupdf");
+    this._loaded = true;
+  }
+
+  async convert(inputPath, outputPath, options = {}) {
+    await this.ensureLoaded();
+
+    const ext = path.extname(inputPath).slice(1).toLowerCase();
+    const mime = MIME_MAP[ext];
+    if (!mime) {
+      throw new Error(`MuPDF: unsupported format .${ext}`);
+    }
+
+    const inputData = fs.readFileSync(inputPath);
+    const pdfBytes = this._renderToPdf(inputData, mime);
+    fs.writeFileSync(outputPath, pdfBytes);
+  }
+
+  // Public method for pipeline use (e.g., pandoc engine passing HTML buffer)
+  async convertBuffer(data, mime, outputPath) {
+    await this.ensureLoaded();
+    const pdfBytes = this._renderToPdf(data, mime);
+    fs.writeFileSync(outputPath, pdfBytes);
+  }
+
+  _renderToPdf(inputData, mime) {
+    const mupdf = this._mupdf;
+    const doc = mupdf.Document.openDocument(inputData, mime);
+    const buf = new mupdf.Buffer();
+    const writer = new mupdf.DocumentWriter(buf, "pdf", "");
+
+    for (let i = 0; i < doc.countPages(); i++) {
+      const page = doc.loadPage(i);
+      const bounds = page.getBounds();
+      const dev = writer.beginPage(bounds);
+      page.run(dev, mupdf.Matrix.identity);
+      writer.endPage();
+    }
+
+    writer.close();
+    return buf.asUint8Array();
+  }
+}

package/src/engines/pandoc.js

@@ -0,0 +1,66 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { Engine } from "./base.js";
+import { MuPdfEngine } from "./mupdf.js";
+
+const SUPPORTED = ["md", "markdown", "html", "htm"];
+
+const PANDOC_FORMAT_MAP = {
+  md: "markdown",
+  markdown: "markdown",
+  html: "html",
+  htm: "html",
+};
+
+export class PandocEngine extends Engine {
+  constructor() {
+    super("pandoc");
+    this._pandoc = null;
+    this._mupdf = new MuPdfEngine();
+  }
+
+  supportedExtensions() {
+    return SUPPORTED;
+  }
+
+  async ensureLoaded() {
+    if (this._loaded) return;
+    this._pandoc = await import("pandoc-wasm");
+    await this._mupdf.ensureLoaded();
+    this._loaded = true;
+  }
+
+  async convert(inputPath, outputPath, options = {}) {
+    await this.ensureLoaded();
+
+    const ext = path.extname(inputPath).slice(1).toLowerCase();
+    const fromFormat = PANDOC_FORMAT_MAP[ext];
+    if (!fromFormat) {
+      throw new Error(`Pandoc: unsupported format .${ext}`);
+    }
+
+    const inputText = fs.readFileSync(inputPath, "utf-8");
+
+    // Stage 1: Convert to standalone HTML via pandoc-wasm
+    let htmlContent;
+    if (fromFormat === "html") {
+      // Already HTML — use directly
+      htmlContent = inputText;
+    } else {
+      const result = await this._pandoc.convert(
+        { from: fromFormat, to: "html", standalone: true },
+        inputText,
+        {}
+      );
+      if (result.stderr) {
+        // pandoc-wasm has no exitCode; check stderr for errors
+        console.error(`Pandoc warnings: ${result.stderr}`);
+      }
+      htmlContent = result.stdout;
+    }
+
+    // Stage 2: Render HTML to PDF via MuPDF's public convertBuffer API
+    const htmlData = new TextEncoder().encode(htmlContent);
+    await this._mupdf.convertBuffer(htmlData, "text/html", outputPath);
+  }
+}

package/src/registry.js

@@ -0,0 +1,39 @@
+const FORMAT_MAP = {
+  // LibreOffice-WASM
+  docx: "libreoffice",
+  doc: "libreoffice",
+  pptx: "libreoffice",
+  ppt: "libreoffice",
+  xlsx: "libreoffice",
+  xls: "libreoffice",
+  odt: "libreoffice",
+  ods: "libreoffice",
+  odp: "libreoffice",
+  rtf: "libreoffice",
+
+  // MuPDF
+  jpg: "mupdf",
+  jpeg: "mupdf",
+  png: "mupdf",
+  svg: "mupdf",
+  tiff: "mupdf",
+  tif: "mupdf",
+  webp: "mupdf",
+
+  // Pandoc pipeline
+  md: "pandoc",
+  markdown: "pandoc",
+  html: "pandoc",
+  htm: "pandoc",
+};
+
+export class Registry {
+  resolve(ext) {
+    const normalized = ext.startsWith(".") ? ext.slice(1) : ext;
+    return FORMAT_MAP[normalized.toLowerCase()] ?? null;
+  }
+
+  supportedExtensions() {
+    return Object.keys(FORMAT_MAP);
+  }
+}