@maistik/nuxt-pdf 1.0.17

package/README.md

@@ -0,0 +1,381 @@
+# @maistik/nuxt-pdf
+
+A powerful Nuxt 3/4 module for server-side PDF generation using Handlebars templates. Generate beautiful, data-driven PDFs with support for multiple providers (Gotenberg, Browserless, Puppeteer Core) and built-in internationalization.
+
+## Features
+
+- 🎨 **Handlebars Templates** - Lightweight templating without Vue overhead
+- 🌍 **Internationalization** - Built-in i18n support with `{{t}}` helper
+- 🔄 **Provider Agnostic** - Support for Gotenberg, Browserless, and Puppeteer Core
+- 🎯 **SSR Safe** - Everything runs server-side in Nitro/Node
+- 🧩 **Composable API** - Easy-to-use `usePdf()` composable
+- 📱 **Responsive Design** - CSS-based layouts with print media queries
+- 🎪 **Playground** - Demo app with sample templates
+
+## Quick Start
+
+### Installation
+
+```bash
+npm install @maistik/nuxt-pdf handlebars
+```
+
+### Configuration
+
+Add the module to your `nuxt.config.ts`:
+
+```typescript
+export default defineNuxtConfig({
+  modules: ['@maistik/nuxt-pdf'],
+  pdf: {
+    provider: 'puppeteer', // or 'gotenberg' or 'browserless'
+    components: ['pdf'],
+    sharedComponents: ['pdf/partials'],
+    enableI18n: true,
+    defaultLocale: 'en',
+    availableLocales: ['en', 'es', 'fr'],
+    i18nMessages: {
+      en: {
+        invoice: {
+          title: 'Invoice',
+          total: 'Total'
+        }
+      },
+      es: {
+        invoice: {
+          title: 'Factura',
+          total: 'Total'
+        }
+      }
+    },
+    providers: {
+      puppeteer: {
+        launchOptions: {
+          headless: true,
+          args: ['--no-sandbox']
+        }
+      }
+    }
+  }
+})
+```
+
+### Create a Template
+
+Create `pdf/Invoice.hbs` in your project:
+
+```handlebars
+<style>
+  @page { size: A4; margin: 20mm; }
+  body { font-family: Arial, sans-serif; }
+  .header { text-align: center; margin-bottom: 30px; }
+  .total { font-weight: bold; font-size: 18px; }
+</style>
+
+<div class="header">
+  <h1>{{t "invoice.title"}}</h1>
+  <p>Invoice #{{invoiceNumber}}</p>
+</div>
+
+<table>
+  {{#each items}}
+  <tr>
+    <td>{{this.description}}</td>
+    <td>{{formatCurrency this.price}}</td>
+  </tr>
+  {{/each}}
+</table>
+
+<div class="total">
+  {{t "invoice.total"}}: {{formatCurrency total}}
+</div>
+```
+
+### Generate PDFs
+
+Use the composable in your Vue components:
+
+```vue
+<script setup>
+const { generate, download } = usePdf()
+
+const generateInvoice = async () => {
+  const data = {
+    invoiceNumber: 'INV-001',
+    items: [
+      { description: 'Service', price: 100 }
+    ],
+    total: 100
+  }
+  
+  // Generate and preview
+  const blob = await generate('Invoice', data, { format: 'A4' }, 'en')
+  
+  // Or download directly
+  await download('Invoice', data, { format: 'A4' }, 'invoice.pdf', 'en')
+}
+</script>
+```
+
+## Providers
+
+### Puppeteer Core (Local)
+
+Best for development and on-premise deployments:
+
+```typescript
+pdf: {
+  provider: 'puppeteer',
+  providers: {
+    puppeteer: {
+      launchOptions: {
+        headless: true,
+        args: ['--no-sandbox', '--disable-setuid-sandbox']
+      }
+    }
+  }
+}
+```
+
+### Gotenberg (Docker)
+
+Perfect for containerized environments:
+
+```typescript
+pdf: {
+  provider: 'gotenberg',
+  providers: {
+    gotenberg: {
+      url: 'http://gotenberg:3000'
+    }
+  }
+}
+```
+
+### Browserless (Cloud)
+
+Great for serverless deployments:
+
+```typescript
+pdf: {
+  provider: 'browserless',
+  providers: {
+    browserless: {
+      url: 'https://chrome.browserless.io',
+      apiKey: process.env.BROWSERLESS_API_KEY
+    }
+  }
+}
+```
+
+## Built-in Helpers
+
+### Internationalization
+```handlebars
+{{t "invoice.title"}} <!-- Outputs localized text -->
+```
+
+### Currency Formatting
+```handlebars
+{{formatCurrency 1234.56}} <!-- $1,234.56 -->
+{{formatCurrency 1234.56 "EUR"}} <!-- €1,234.56 -->
+```
+
+### Date Formatting
+```handlebars
+{{formatDate date}} <!-- 12/25/2024 -->
+{{formatDate date "full"}} <!-- Wednesday, December 25, 2024 -->
+```
+
+### Number Formatting
+```handlebars
+{{formatNumber 1234.56}} <!-- 1,234.56 -->
+{{formatNumber 0.15 style="percent"}} <!-- 15% -->
+```
+
+### Math Operations
+```handlebars
+{{add 10 5}} <!-- 15 -->
+{{subtract 10 5}} <!-- 5 -->
+{{multiply 10 5}} <!-- 50 -->
+{{divide 10 5}} <!-- 2 -->
+{{percentage 25 100}} <!-- 25% -->
+```
+
+## Custom Helpers
+
+You can define your own custom helpers in the configuration:
+
+```typescript
+pdf: {
+  customHelpers: {
+    // Simple value transformation
+    customFormat: (value: any) => `[${value}]`,
+    
+    // String manipulation
+    repeat: (str: string, times: number) => str.repeat(times || 1),
+    
+    // Block helper with conditional logic
+    ifEquals: function(this: any, arg1: any, arg2: any, options: any) {
+      return (arg1 === arg2) ? options.fn(this) : options.inverse(this)
+    }
+  }
+}
+```
+
+Use them in templates:
+```handlebars
+{{customFormat "hello"}} <!-- [hello] -->
+{{repeat "★" 5}} <!-- ★★★★★ -->
+{{#ifEquals status "active"}}Active User{{else}}Inactive User{{/ifEquals}}
+```
+
+### String Helpers
+```handlebars
+{{upper "hello world"}} <!-- HELLO WORLD -->
+{{lower "HELLO WORLD"}} <!-- hello world -->
+{{capitalize "hello world"}} <!-- Hello world -->
+{{truncate "Long text here" 10}} <!-- Long text... -->
+```
+
+### Line Calculations
+```handlebars
+{{lineTotal quantity price}} <!-- quantity * price -->
+```
+
+## Template Features
+
+### Automatic Enrichment
+
+The module automatically enriches your data based on template names:
+
+**Invoice Templates** get:
+- `subtotal` - Sum of all line items
+- `tax` - Calculated tax amount
+- `total` - Subtotal + tax
+- `dueDate` - Calculated from issue date + payment terms
+
+**Sales Report Templates** get:
+- `quarters` - Quarterly breakdown of sales data
+- `rating` - Performance rating based on total sales
+
+### CSS Styling
+
+Use standard CSS with print-specific rules:
+
+```css
+@page {
+  size: A4;
+  margin: 20mm;
+}
+
+.page-break {
+  page-break-before: always;
+}
+
+@media print {
+  .no-break {
+    page-break-inside: avoid;
+  }
+}
+```
+
+### Partials
+
+Create reusable components in your `sharedComponents` directory:
+
+```handlebars
+<!-- pdf/partials/header.hbs -->
+<div class="header">
+  <h1>{{title}}</h1>
+  <p>{{subtitle}}</p>
+</div>
+```
+
+Use in templates:
+```handlebars
+{{> header title="My Document" subtitle="Generated Report"}}
+```
+
+## API Reference
+
+### `usePdf()`
+
+The main composable for PDF operations:
+
+```typescript
+const {
+  generate,    // (template, data, options?, locale?) => Promise<Blob>
+  download,    // (template, data, options?, filename?, locale?) => Promise<void>
+  getAvailableLocales, // () => string[]
+  getDefaultLocale     // () => string
+} = usePdf()
+```
+
+### Options
+
+```typescript
+interface PdfOptions {
+  format?: 'A4' | 'Letter' | 'Legal'
+  margin?: {
+    top?: number
+    bottom?: number  
+    left?: number
+    right?: number
+  }
+  landscape?: boolean
+  printBackground?: boolean
+  pageBreak?: {
+    before?: string[]
+    after?: string[]
+    avoid?: string[]
+  }
+}
+```
+
+## Development
+
+### Playground
+
+The module includes a full playground application:
+
+```bash
+npm run dev
+```
+
+This starts a demo app with sample Invoice and Sales Report templates in multiple languages.
+
+### Building
+
+```bash
+npm run build
+```
+
+### Testing
+
+```bash
+npm run test
+```
+
+## Examples
+
+Check out the `playground/` directory for complete examples including:
+
+- **Invoice Template** - Complete invoice with line items, taxes, and totals
+- **Sales Report Template** - Comprehensive report with metrics and quarterly breakdown
+- **Multi-language Support** - Templates in English, Spanish, and French
+- **Multiple Providers** - Configuration examples for all supported providers
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please read our contributing guidelines and submit pull requests to our repository.
+
+## Support
+
+- 📖 [Documentation](https://github.com/Maistik-Studio/nuxt-pdf)
+- 🐛 [Issue Tracker](https://github.com/Maistik-Studio/nuxt-pdf/issues)
+- 💬 [Discussions](https://github.com/Maistik-Studio/nuxt-pdf/discussions)

package/dist/module.d.mts

@@ -0,0 +1,44 @@
+import { HelperDelegate } from 'handlebars';
+
+interface PdfModuleOptions {
+    provider: 'gotenberg' | 'browserless' | 'puppeteer';
+    components: string[];
+    sharedComponents: string[];
+    enableI18n: boolean;
+    defaultLocale: string;
+    availableLocales: string[];
+    i18nMessages: Record<string, Record<string, string>>;
+    providers: {
+        gotenberg: {
+            url: string;
+        };
+        browserless: {
+            url: string;
+            apiKey: string;
+        };
+        puppeteer: {
+            launchOptions: Record<string, any>;
+        };
+    };
+    defaultOptions: {
+        format: string;
+        margin: {
+            top: number;
+            bottom: number;
+            left: number;
+            right: number;
+        };
+        landscape: boolean;
+        printBackground: boolean;
+        pageBreak: {
+            before: string[];
+            after: string[];
+            avoid: string[];
+        };
+    };
+    customHelpers?: Record<string, HelperDelegate>;
+}
+declare const _default: any;
+
+export { _default as default };
+export type { PdfModuleOptions };

package/dist/module.d.ts

@@ -0,0 +1,44 @@
+import { HelperDelegate } from 'handlebars';
+
+interface PdfModuleOptions {
+    provider: 'gotenberg' | 'browserless' | 'puppeteer';
+    components: string[];
+    sharedComponents: string[];
+    enableI18n: boolean;
+    defaultLocale: string;
+    availableLocales: string[];
+    i18nMessages: Record<string, Record<string, string>>;
+    providers: {
+        gotenberg: {
+            url: string;
+        };
+        browserless: {
+            url: string;
+            apiKey: string;
+        };
+        puppeteer: {
+            launchOptions: Record<string, any>;
+        };
+    };
+    defaultOptions: {
+        format: string;
+        margin: {
+            top: number;
+            bottom: number;
+            left: number;
+            right: number;
+        };
+        landscape: boolean;
+        printBackground: boolean;
+        pageBreak: {
+            before: string[];
+            after: string[];
+            avoid: string[];
+        };
+    };
+    customHelpers?: Record<string, HelperDelegate>;
+}
+declare const _default: any;
+
+export { _default as default };
+export type { PdfModuleOptions };

package/dist/module.json

@@ -0,0 +1,12 @@
+{
+  "name": "@maistik/nuxt-pdf",
+  "configKey": "pdf",
+  "compatibility": {
+    "nuxt": "^3.0.0"
+  },
+  "version": "1.0.17",
+  "builder": {
+    "@nuxt/module-builder": "1.0.1",
+    "unbuild": "3.5.0"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,113 @@
+import { defineNuxtModule, createResolver, addServerHandler, addImports } from '@nuxt/kit';
+import { existsSync, readdirSync, statSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+const module = defineNuxtModule({
+  meta: {
+    name: "@maistik/nuxt-pdf",
+    configKey: "pdf",
+    compatibility: {
+      nuxt: "^3.0.0"
+    }
+  },
+  defaults: {
+    provider: "gotenberg",
+    components: ["pdf"],
+    sharedComponents: ["pdf/partials"],
+    enableI18n: true,
+    defaultLocale: "en",
+    availableLocales: ["en"],
+    i18nMessages: {},
+    providers: {
+      gotenberg: {
+        url: "http://localhost:3000"
+      },
+      browserless: {
+        url: "https://chrome.browserless.io",
+        apiKey: ""
+      },
+      puppeteer: {
+        launchOptions: {
+          headless: true,
+          args: ["--no-sandbox", "--disable-setuid-sandbox"]
+        }
+      }
+    },
+    customHelpers: {},
+    defaultOptions: {
+      format: "A4",
+      margin: {
+        top: 20,
+        bottom: 20,
+        left: 20,
+        right: 20
+      },
+      landscape: false,
+      printBackground: true,
+      pageBreak: {
+        before: ["always"],
+        after: ["always"],
+        avoid: [".no-break"]
+      }
+    }
+  },
+  setup(options, nuxt) {
+    const resolver = createResolver(import.meta.url);
+    const templateSources = {};
+    const partialSources = {};
+    for (const componentDir of options.components) {
+      const fullPath = join(nuxt.options.srcDir, componentDir);
+      if (existsSync(fullPath)) {
+        scanDirectory(fullPath, templateSources, ".hbs");
+      }
+    }
+    for (const sharedDir of options.sharedComponents) {
+      const fullPath = join(nuxt.options.srcDir, sharedDir);
+      if (existsSync(fullPath)) {
+        scanDirectory(fullPath, partialSources, ".hbs");
+      }
+    }
+    nuxt.options.runtimeConfig.pdf = {
+      provider: options.provider,
+      enableI18n: options.enableI18n,
+      defaultLocale: options.defaultLocale,
+      availableLocales: options.availableLocales,
+      i18nMessages: options.i18nMessages,
+      providers: options.providers,
+      defaultOptions: options.defaultOptions,
+      templateSources,
+      partialSources,
+      customHelpers: options.customHelpers || {}
+    };
+    nuxt.options.runtimeConfig.public.pdf = {
+      enableI18n: options.enableI18n,
+      defaultLocale: options.defaultLocale,
+      availableLocales: options.availableLocales
+    };
+    addServerHandler({
+      route: "/api/pdf",
+      handler: resolver.resolve("./runtime/server/api/pdf.post")
+    });
+    addImports({
+      name: "usePdf",
+      as: "usePdf",
+      from: resolver.resolve("./runtime/composables/usePdf")
+    });
+  }
+});
+function scanDirectory(dir, sources, extension) {
+  if (!existsSync(dir)) return;
+  const files = readdirSync(dir);
+  for (const file of files) {
+    const filePath = join(dir, file);
+    const stat = statSync(filePath);
+    if (stat.isDirectory()) {
+      scanDirectory(filePath, sources, extension);
+    } else if (file.endsWith(extension)) {
+      const templateName = file.replace(extension, "");
+      sources[templateName] = readFileSync(filePath, "utf-8");
+    }
+  }
+}
+
+export { module as default };

package/dist/runtime/composables/usePdf.d.ts

@@ -0,0 +1,22 @@
+export interface PdfGenerateOptions {
+    format?: string;
+    margin?: {
+        top?: number;
+        bottom?: number;
+        left?: number;
+        right?: number;
+    };
+    landscape?: boolean;
+    printBackground?: boolean;
+    pageBreak?: {
+        before?: string[];
+        after?: string[];
+        avoid?: string[];
+    };
+}
+export declare function usePdf(): {
+    generate: (template: string, data: any, options?: PdfGenerateOptions, locale?: string) => Promise<Blob>;
+    download: (template: string, data: any, options?: PdfGenerateOptions, filename?: string, locale?: string) => Promise<void>;
+    getAvailableLocales: () => string[];
+    getDefaultLocale: () => string;
+};

package/dist/runtime/composables/usePdf.js

@@ -0,0 +1,42 @@
+import { useRuntimeConfig } from "#imports";
+export function usePdf() {
+  const config = useRuntimeConfig();
+  const generate = async (template, data, options = {}, locale) => {
+    const response = await $fetch("/api/pdf", {
+      method: "POST",
+      body: {
+        template,
+        ctx: {
+          data,
+          options,
+          locale: locale || config.public.pdf.defaultLocale
+        }
+      },
+      responseType: "arrayBuffer"
+    });
+    return new Blob([response], { type: "application/pdf" });
+  };
+  const download = async (template, data, options = {}, filename = "document.pdf", locale) => {
+    const blob = await generate(template, data, options, locale);
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = filename;
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    URL.revokeObjectURL(url);
+  };
+  const getAvailableLocales = () => {
+    return config.public.pdf.availableLocales || ["en"];
+  };
+  const getDefaultLocale = () => {
+    return config.public.pdf.defaultLocale || "en";
+  };
+  return {
+    generate,
+    download,
+    getAvailableLocales,
+    getDefaultLocale
+  };
+}

package/dist/runtime/server/api/pdf.post.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/pdf.post.js

@@ -0,0 +1,31 @@
+import { defineEventHandler, readBody, setHeader } from "h3";
+import { useRuntimeConfig } from "#imports";
+import { compilePdfComponent } from "../../utils/compiler.js";
+import { createPdfProvider } from "../../utils/providers.js";
+export default defineEventHandler(async (event) => {
+  try {
+    const config = useRuntimeConfig();
+    const { template, ctx } = await readBody(event);
+    if (!template || !ctx) {
+      throw new Error("Missing template or context");
+    }
+    const { data, options = {}, locale } = ctx;
+    const mergedOptions = { ...config.pdf.defaultOptions, ...options };
+    const messages = config.pdf.enableI18n ? config.pdf.i18nMessages[locale || config.pdf.defaultLocale] || {} : {};
+    const html = compilePdfComponent(
+      template,
+      { data, options: mergedOptions, locale },
+      messages,
+      config.pdf.templateSources,
+      config.pdf.partialSources
+    );
+    const provider = createPdfProvider(config.pdf.provider, config.pdf.providers);
+    const pdfBuffer = await provider.generatePdf(html, mergedOptions);
+    setHeader(event, "Content-Type", "application/pdf");
+    setHeader(event, "Content-Length", pdfBuffer.length.toString());
+    return pdfBuffer;
+  } catch (error) {
+    console.error("PDF generation error:", error);
+    throw error;
+  }
+});

package/dist/runtime/types.d.ts

@@ -0,0 +1,36 @@
+export interface PdfContext {
+    data: any;
+    options: PdfOptions;
+    locale?: string;
+}
+export interface PdfOptions {
+    format?: 'A4' | 'Letter' | 'Legal';
+    margin?: {
+        top?: number;
+        bottom?: number;
+        left?: number;
+        right?: number;
+    };
+    landscape?: boolean;
+    printBackground?: boolean;
+    pageBreak?: {
+        before?: string[];
+        after?: string[];
+        avoid?: string[];
+    };
+}
+export interface PdfProviderConfig {
+    gotenberg: {
+        url: string;
+    };
+    browserless: {
+        url: string;
+        apiKey: string;
+    };
+    puppeteer: {
+        launchOptions: Record<string, any>;
+    };
+}
+export interface PdfProvider {
+    generatePdf(html: string, options: any): Promise<Buffer>;
+}

package/dist/runtime/utils/compiler.d.ts

@@ -0,0 +1,5 @@
+export declare function compilePdfComponent(templateName: string, ctx: {
+    data: any;
+    options: any;
+    locale?: string;
+}, messages: Record<string, string>, templateSources: Record<string, string>, partialSources: Record<string, string>): string;

package/dist/runtime/utils/compiler.js

@@ -0,0 +1,185 @@
+import { useRuntimeConfig } from "#imports";
+import Handlebars from "handlebars";
+export function compilePdfComponent(templateName, ctx, messages, templateSources, partialSources) {
+  const handlebars = Handlebars.create();
+  handlebars.registerHelper("t", function(key) {
+    const keys = key.split(".");
+    let value = messages;
+    for (const k of keys) {
+      if (value && typeof value === "object" && k in value) {
+        value = value[k];
+      } else {
+        return key;
+      }
+    }
+    return typeof value === "string" ? value : key;
+  });
+  handlebars.registerHelper("formatCurrency", function(value, currencyOrOptions) {
+    if (typeof value !== "number") {
+      return value;
+    }
+    let currency = "USD";
+    if (typeof currencyOrOptions === "string") {
+      currency = currencyOrOptions;
+    } else if (currencyOrOptions && typeof currencyOrOptions.hash?.currency === "string") {
+      currency = currencyOrOptions.hash.currency;
+    }
+    if (!/^[A-Z]{3}$/.test(currency)) {
+      currency = "USD";
+    }
+    return new Intl.NumberFormat(ctx.locale || "en-US", {
+      style: "currency",
+      currency
+    }).format(value);
+  });
+  handlebars.registerHelper("lineTotal", function(qty, price) {
+    return (qty * price).toFixed(2);
+  });
+  handlebars.registerHelper("eq", function(a, b, options) {
+    const isEqual = a === b;
+    if (options && typeof options.fn === "function") {
+      return isEqual ? options.fn(this) : options.inverse(this);
+    }
+    return isEqual;
+  });
+  handlebars.registerHelper(
+    "ne",
+    (a, b, opts) => a !== b ? opts.fn(this) : opts.inverse(this)
+  );
+  handlebars.registerHelper(
+    "gt",
+    (a, b, opts) => a > b ? opts.fn(this) : opts.inverse(this)
+  );
+  handlebars.registerHelper("formatDate", function(date, formatOrOptions) {
+    let style = "short";
+    if (typeof formatOrOptions === "string") {
+      style = formatOrOptions;
+    } else if (formatOrOptions && typeof formatOrOptions.hash?.format === "string") {
+      style = formatOrOptions.hash.format;
+    }
+    if (!["full", "long", "medium", "short"].includes(style)) {
+      style = "short";
+    }
+    let dateObj;
+    if (typeof date === "string") {
+      dateObj = new Date(date);
+    } else if (date instanceof Date) {
+      dateObj = date;
+    } else {
+      dateObj = /* @__PURE__ */ new Date();
+    }
+    if (isNaN(dateObj.getTime())) {
+      dateObj = /* @__PURE__ */ new Date();
+    }
+    return new Intl.DateTimeFormat(ctx.locale || "en-US", {
+      dateStyle: style
+    }).format(dateObj);
+  });
+  handlebars.registerHelper("formatNumber", function(value, options = {}) {
+    if (typeof value !== "number") return value;
+    return new Intl.NumberFormat(ctx.locale || "en-US", options).format(value);
+  });
+  try {
+    const config = useRuntimeConfig();
+    const customHelpers = config.pdf.customHelpers;
+    if (customHelpers && typeof customHelpers === "object") {
+      Object.entries(customHelpers).forEach(([name, helper]) => {
+        if (typeof helper === "function") {
+          handlebars.registerHelper(name, helper);
+        }
+      });
+    }
+  } catch (error) {
+    console.warn("Failed to load custom helpers:", error);
+  }
+  handlebars.registerHelper("upper", function(str) {
+    return String(str || "").toUpperCase();
+  });
+  handlebars.registerHelper("lower", function(str) {
+    return String(str || "").toLowerCase();
+  });
+  handlebars.registerHelper("capitalize", function(str) {
+    return String(str || "").charAt(0).toUpperCase() + String(str || "").slice(1).toLowerCase();
+  });
+  handlebars.registerHelper("truncate", function(str, length) {
+    const text = String(str || "");
+    return text.length > length ? `${text.substring(0, length)}...` : text;
+  });
+  handlebars.registerHelper("multiply", function(a, b) {
+    return (a || 0) * (b || 0);
+  });
+  handlebars.registerHelper("add", function(a, b) {
+    return (a || 0) + (b || 0);
+  });
+  handlebars.registerHelper("subtract", function(a, b) {
+    return (a || 0) - (b || 0);
+  });
+  handlebars.registerHelper("divide", function(a, b) {
+    return b !== 0 ? (a || 0) / b : 0;
+  });
+  handlebars.registerHelper("percentage", function(value, total) {
+    return total !== 0 ? `${((value || 0) / total * 100).toFixed(2)}%` : "0%";
+  });
+  Object.entries(partialSources).forEach(([name, source]) => {
+    handlebars.registerPartial(name, source);
+  });
+  const templateSource = templateSources[templateName];
+  if (!templateSource) {
+    throw new Error(`Template "${templateName}" not found`);
+  }
+  const template = handlebars.compile(templateSource);
+  const enrichedData = enrichContextForTemplate(templateName, ctx.data);
+  return template({
+    ...enrichedData,
+    options: ctx.options,
+    locale: ctx.locale
+  });
+}
+function enrichContextForTemplate(templateName, data) {
+  const enriched = { ...data };
+  if (templateName.toLowerCase().includes("invoice")) {
+    if (enriched.items && Array.isArray(enriched.items)) {
+      enriched.subtotal = enriched.items.reduce((sum, item) => {
+        return sum + item.quantity * item.price;
+      }, 0);
+      enriched.tax = enriched.subtotal * (enriched.taxRate || 0.1);
+      enriched.total = enriched.subtotal + enriched.tax;
+      if (enriched.issueDate && enriched.paymentTerms) {
+        const issueDate = new Date(enriched.issueDate);
+        const dueDate = new Date(issueDate);
+        dueDate.setDate(dueDate.getDate() + enriched.paymentTerms);
+        enriched.dueDate = dueDate;
+      }
+    }
+  }
+  if (templateName.toLowerCase().includes("salesreport")) {
+    if (enriched.salesData && Array.isArray(enriched.salesData)) {
+      enriched.quarters = calculateQuarters(enriched.salesData);
+      const totalSales = enriched.salesData.reduce((sum, item) => sum + item.amount, 0);
+      enriched.rating = calculatePerformanceRating(totalSales);
+    }
+  }
+  return enriched;
+}
+function calculateQuarters(salesData) {
+  const quarters = [
+    { name: "Q1", months: [0, 1, 2], total: 0 },
+    { name: "Q2", months: [3, 4, 5], total: 0 },
+    { name: "Q3", months: [6, 7, 8], total: 0 },
+    { name: "Q4", months: [9, 10, 11], total: 0 }
+  ];
+  salesData.forEach((item) => {
+    const month = new Date(item.date).getMonth();
+    const quarter = quarters.find((q) => q.months.includes(month));
+    if (quarter) {
+      quarter.total += item.amount;
+    }
+  });
+  return quarters;
+}
+function calculatePerformanceRating(totalSales) {
+  if (totalSales >= 1e5) return "Excellent";
+  if (totalSales >= 75e3) return "Good";
+  if (totalSales >= 5e4) return "Average";
+  return "Needs Improvement";
+}

package/dist/runtime/utils/providers.d.ts

@@ -0,0 +1,2 @@
+import type { PdfProvider } from '../types.js';
+export declare function createPdfProvider(providerType: string, config: any): PdfProvider;

package/dist/runtime/utils/providers.js

@@ -0,0 +1,118 @@
+import FormData from "form-data";
+export function createPdfProvider(providerType, config) {
+  switch (providerType) {
+    case "gotenberg":
+      return new GotenbergProvider(config.gotenberg);
+    case "browserless":
+      return new BrowserlessProvider(config.browserless);
+    case "puppeteer":
+      return new PuppeteerProvider(config.puppeteer);
+    default:
+      throw new Error(`Unknown PDF provider: ${providerType}`);
+  }
+}
+class GotenbergProvider {
+  constructor(config) {
+    this.config = config;
+  }
+  async generatePdf(html, options) {
+    const form = new FormData();
+    const htmlBuffer = Buffer.from(html, "utf8");
+    form.append("files", htmlBuffer, {
+      filename: "index.html",
+      contentType: "text/html",
+      knownLength: htmlBuffer.length
+    });
+    if (options.format) {
+      const dimensions = this.getPageDimensions(options.format);
+      form.append("paperWidth", dimensions.width);
+      form.append("paperHeight", dimensions.height);
+    }
+    if (options.margin) {
+      form.append("marginTop", (options.margin.top / 25.4).toString());
+      form.append("marginBottom", (options.margin.bottom / 25.4).toString());
+      form.append("marginLeft", (options.margin.left / 25.4).toString());
+      form.append("marginRight", (options.margin.right / 25.4).toString());
+    }
+    if (options.landscape) {
+      form.append("landscape", "true");
+    }
+    if (options.printBackground) {
+      form.append("printBackground", "true");
+    }
+    form.append("waitForNetworkIdle", "true");
+    form.append("waitDelay", "1s");
+    const bodyBuffer = form.getBuffer();
+    const headers = {
+      ...form.getHeaders(),
+      // multipart/form-data; boundary=XXX
+      "Content-Length": bodyBuffer.length.toString()
+    };
+    const response = await fetch(`${this.config.url}/forms/chromium/convert/html`, {
+      method: "POST",
+      body: bodyBuffer,
+      headers
+    });
+    if (!response.ok) {
+      throw new Error(`Gotenberg error: ${response.statusText}`);
+    }
+    return Buffer.from(await response.arrayBuffer());
+  }
+  getPageDimensions(format) {
+    const formats = {
+      A4: { width: "8.27in", height: "11.69in" },
+      Letter: { width: "8.5in", height: "11in" },
+      Legal: { width: "8.5in", height: "14in" }
+    };
+    return formats[format] || formats["A4"];
+  }
+}
+class BrowserlessProvider {
+  constructor(config) {
+    this.config = config;
+  }
+  async generatePdf(html, options) {
+    const response = await fetch(`${this.config.url}/pdf?token=${this.config.apiKey}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        html,
+        options: {
+          format: options.format || "A4",
+          margin: options.margin,
+          landscape: options.landscape || false,
+          printBackground: options.printBackground !== false
+        }
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Browserless error: ${response.statusText}`);
+    }
+    return Buffer.from(await response.arrayBuffer());
+  }
+}
+class PuppeteerProvider {
+  constructor(config) {
+    this.config = config;
+  }
+  async generatePdf(html, options) {
+    const puppeteer = await import("puppeteer").then((m) => m.default);
+    const browser = await puppeteer.launch(this.config.launchOptions);
+    try {
+      const page = await browser.newPage();
+      await page.setContent(html, { waitUntil: "networkidle0" });
+      const pdfOptions = {
+        format: options.format || "A4",
+        margin: options.margin,
+        landscape: options.landscape || false,
+        printBackground: options.printBackground !== false
+      };
+      const pdfBuffer = await page.pdf(pdfOptions);
+      return Buffer.from(pdfBuffer);
+    } finally {
+      await browser.close();
+    }
+  }
+}

package/dist/types.d.mts

@@ -0,0 +1,9 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module.mjs'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { default } from './module.mjs'
+
+export { type PdfModuleOptions } from './module.mjs'

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@maistik/nuxt-pdf",
+  "version": "1.0.17",
+  "description": "A Nuxt 3 module for server-side PDF generation using Handlebars templates",
+  "type": "module",
+  "private": false,
+  "main": "./dist/module.mjs",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "nuxt-module-build prepare && nuxt-module-build build",
+    "dev": "nuxi dev playground",
+    "dev:build": "nuxi build playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
+    "release": "npm run lint && npm run test:unit && npm run prepack && changelogen --release && npm publish --access public && git push --follow-tags",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "test": "vitest run && playwright test",
+    "test:watch": "vitest watch",
+    "test:unit": "vitest run",
+    "test:e2e": "playwright test",
+    "test:e2e:ui": "playwright test --ui",
+    "prepack": "nuxt-module-build build"
+  },
+  "dependencies": {
+    "@nuxt/kit": "^3.17.7",
+    "handlebars": "^4.7.8",
+    "puppeteer": "^24.14.0",
+    "form-data": "^4.0.4"
+  },
+  "devDependencies": {
+    "@nuxt/devtools": "latest",
+    "@nuxt/eslint-config": "^1.6.0",
+    "@nuxt/module-builder": "^1.0.1",
+    "@nuxt/schema": "^3.17.7",
+    "@nuxt/test-utils": "^3.19.2",
+    "@playwright/test": "^1.49.1",
+    "changelogen": "^0.6.2",
+    "eslint": "^9.31.0",
+    "nuxt": "^3.17.7",
+    "unbuild": "^3.5.0",
+    "vitest": "^3.2.4"
+  },
+  "keywords": [
+    "nuxt",
+    "nuxt3",
+    "pdf",
+    "handlebars",
+    "gotenberg",
+    "browserless",
+    "puppeteer"
+  ],
+  "author": "Maistik Studio",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Maistik-Studio/nuxt-pdf"
+  },
+  "packageManager": "pnpm@9.15.3"
+}