@lupinum/nuxt-pdf 0.3.0

package/README.md

@@ -0,0 +1,203 @@
+<p align="center">
+  <img src="docs/public/logo.svg" width="128" alt="Nuxt PDF">
+</p>
+
+<h1 align="center">Nuxt PDF</h1>
+
+<p align="center">
+  Author and render PDFs with Vue components in Nuxt.
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@lupinum/nuxt-pdf"><img src="https://img.shields.io/npm/v/@lupinum/nuxt-pdf?color=315d3b" alt="npm version"></a>
+  <a href="https://github.com/lupinum-dev/nuxt-pdf/actions/workflows/ci.yml"><img src="https://github.com/lupinum-dev/nuxt-pdf/actions/workflows/ci.yml/badge.svg" alt="CI status"></a>
+  <a href="./LICENSE"><img src="https://img.shields.io/badge/license-MIT-315d3b" alt="MIT license"></a>
+</p>
+
+> [!IMPORTANT]
+> Nuxt PDF is an external alpha. Its tested behavior is stable within each
+> release, but a minor release can contain documented breaking changes before
+> version 1.0.
+
+Nuxt PDF discovers Vue Single File Components in `pdfs/`. It renders these
+components on the Node server through a PDF layout engine. The client bundle
+does not contain the renderer or document templates.
+
+Use Nuxt PDF for structured documents such as invoices, reports,
+certificates, tickets, and labels.
+
+Do not use Nuxt PDF to print an existing web page, display an existing PDF, or
+edit and sign an existing PDF.
+
+## Requirements
+
+- Node.js `^22.14.0`, `^24.0.0`, or `^26.0.0`
+- Nuxt `^4.4.8`
+- Vue `^3.5.0`
+
+Nuxt 3, Node 20, browser rendering, and edge rendering are outside the current
+support boundary.
+
+## Install
+
+Install the module in a Nuxt 4 application:
+
+```bash
+pnpm add @lupinum/nuxt-pdf
+```
+
+Add the module to `nuxt.config.ts`:
+
+```ts
+export default defineNuxtConfig({
+  modules: ['@lupinum/nuxt-pdf'],
+})
+```
+
+## Render a document
+
+Create `pdfs/invoice.vue`:
+
+```vue
+<script setup lang="ts">
+type InvoiceProps = {
+  invoice: {
+    customer: string
+    number: string
+    total: string
+  }
+}
+
+const props = defineProps<InvoiceProps>()
+
+definePdf<InvoiceProps>({
+  title: ({ invoice }) => `Invoice ${invoice.number}`,
+  filename: ({ invoice }) => `invoice-${invoice.number}.pdf`,
+  sampleData: {
+    invoice: {
+      customer: 'Ada Lovelace',
+      number: 'INV-001',
+      total: 'EUR 1,250.00',
+    },
+  },
+})
+</script>
+
+<template>
+  <PdfDocument>
+    <PdfPage size="A4" :style="{ fontSize: 11, padding: 48 }">
+      <PdfText :style="{ fontSize: 24, marginBottom: 24 }">
+        Invoice {{ props.invoice.number }}
+      </PdfText>
+      <PdfText>{{ props.invoice.customer }}</PdfText>
+      <PdfText :style="{ marginTop: 12 }">
+        Total: {{ props.invoice.total }}
+      </PdfText>
+    </PdfPage>
+  </PdfDocument>
+</template>
+```
+
+Create `server/api/invoice.get.ts`:
+
+```ts
+import { pdf } from '#pdf'
+
+export default defineEventHandler(async () => {
+  const result = await pdf.invoice.render({
+    invoice: {
+      customer: 'Ada Lovelace',
+      number: 'INV-001',
+      total: 'EUR 1,250.00',
+    },
+  })
+
+  return result.response()
+})
+```
+
+Start Nuxt. Open these development routes:
+
+- `/_pdf` lists the discovered templates.
+- `/_pdf/invoice` shows the document preview.
+- `/api/invoice` returns the production-style PDF response.
+
+Restart `nuxt dev` after you first enable the module. This action generates
+the typed `#pdf` registry.
+
+## Authoring model
+
+PDF templates use typed props, interpolation, `v-if`, keyed `v-for`, slots,
+and local Vue components. Nuxt PDF provides document, page, text, image, link,
+note, and SVG primitives.
+
+Templates run in an isolated Vue application on the Node server. They do not
+inherit Nuxt plugins, app-level provides, browser globals, or DOM components.
+Load request data before the render and pass it through typed props.
+
+Nuxt PDF supports local images and fonts. Remote images are disabled until an
+operator configures an explicit HTTPS allowlist.
+
+Read the [documentation](https://nuxt-pdf.lupinum.com) for authoring, assets,
+links, bookmarks, tables of contents, testing, and the complete API reference.
+Read [CONFORMANCE.md](./CONFORMANCE.md) for the exact tested behavior and known
+limitations.
+
+## Test a document
+
+Install the optional test dependencies:
+
+```bash
+pnpm add -D pdfjs-dist @napi-rs/canvas
+```
+
+Render the real template in a test:
+
+```ts
+import { expectPdf, renderPdfSfc } from '@lupinum/nuxt-pdf/test'
+
+const { parsed } = await renderPdfSfc('./pdfs/invoice.vue', {
+  invoice: {
+    customer: 'Ada Lovelace',
+    number: 'INV-001',
+    total: 'EUR 1,250.00',
+  },
+})
+
+expectPdf(parsed)
+  .toHavePageCount(1)
+  .toContainText('Invoice INV-001')
+```
+
+The test entry can also inspect links, bookmarks, page geometry, and raster
+baselines.
+
+## Develop Nuxt PDF
+
+```bash
+pnpm install --frozen-lockfile
+pnpm dev
+pnpm check
+```
+
+Use `pnpm docs:dev` to run the documentation site. Use
+`pnpm release:verify` only for release preparation.
+
+Read [CONTRIBUTING.md](./CONTRIBUTING.md) before you open a pull request.
+Maintainers use [MAINTAINING.md](./MAINTAINING.md) for release and recovery
+procedures.
+
+## Support and security
+
+- Read the [documentation](https://nuxt-pdf.lupinum.com).
+- Join the [Lupinum OSS Discord](https://discord.gg/RPH6SeA36N).
+- Open a [GitHub issue](https://github.com/lupinum-dev/nuxt-pdf/issues) for a
+  reproducible defect.
+- Follow [SECURITY.md](./SECURITY.md) for a private vulnerability report.
+
+## License
+
+[MIT](./LICENSE) © Lupinum OG and contributors.
+
+Third-party attributions are in
+[THIRD_PARTY_NOTICES.md](./THIRD_PARTY_NOTICES.md).

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,75 @@
+# Third-party notices
+
+## React PDF
+
+Nuxt PDF uses the published lower-level React PDF engine packages and carries
+paired test fixtures derived from the React PDF repository at commit
+`d41a8207fb06a56e60fcb53ac0e18ce27e7d32d6`.
+
+React PDF is distributed under the following MIT license:
+
+```text
+MIT License
+
+Copyright (c) 2017-present Diego Muracciole <diegomuracciole@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
+The exact engine packages and versions are recorded in
+`src/runtime/server/engine/CONTRACTS.md`; the package build carries that record
+at `dist/runtime/server/engine/CONTRACTS.md`. Their own package distributions
+remain subject to their included licenses.
+
+## Fixture provenance
+
+The following files originate from the React PDF test suite at the commit
+above and are retained only as local conformance, integration, or playground
+fixtures:
+
+| Nuxt PDF fixture | React PDF source |
+|---|---|
+| `test/fixtures/assets/Roboto-Regular.ttf` | `packages/layout/tests/assets/font.ttf` |
+| `test/fixtures/assets/sample.png` | `packages/layout/tests/assets/test.png` |
+
+The copies under `test/fixtures/basic/pdfs/` use the same fixture bytes. The
+playground copies the font as `pdfs/fonts/Roboto-Regular.ttf` and the image as
+`pdfs/assets/alpine.png`.
+
+The font identifies itself as Roboto Regular, copyright 2011 Google Inc., by
+Christian Robertson, and as licensed under the Apache License 2.0:
+<https://www.apache.org/licenses/LICENSE-2.0>.
+
+These fixture binaries are not included in the published Nuxt PDF package.
+
+## Source Code Pro test dependency
+
+The development-only `source-code-pro` npm package supplies OTF and variable
+font fixtures for executable compatibility tests. Source Code Pro is Copyright
+2010–2023 Adobe and distributed under the SIL Open Font License 1.1. It is not
+included in the published Nuxt PDF package; its license is included in the npm
+dependency at `source-code-pro/LICENSE.md`.
+
+## Noto international typography subsets
+
+The test-only international typography fixture contains small FontTools subsets
+of Noto Sans SC Variable, Noto Sans Arabic Variable, and Noto Emoji Variable.
+They retain only the characters used by the executable calibration document,
+are distributed under the SIL Open Font License 1.1 included beside the files,
+and are not included in the published Nuxt PDF package.

package/dist/module.d.mts

@@ -0,0 +1,24 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { RemoteAssetOptions } from '../dist/runtime/server/assets/remote.js';
+export { RemoteAssetOptions } from '../dist/runtime/server/assets/remote.js';
+import { PdfLimitsOptions } from '../dist/runtime/server/render-limits.js';
+export { PdfLimitsOptions } from '../dist/runtime/server/render-limits.js';
+import { PdfFontDeclaration } from '../dist/runtime/fonts.js';
+export { PdfFontDeclaration, PdfFontStyle, PdfFontWeight, PdfFontWeightName } from '../dist/runtime/fonts.js';
+export { PdfLength, PdfLengthOrPercentage, PdfPercentage, PdfStyle, PdfStyleEntry, PdfStyleValue } from '../dist/runtime/authoring.js';
+export { PdfBaseProps, PdfBookmark, PdfCircleProps, PdfClipPathProps, PdfDefsProps, PdfDocumentProps, PdfEllipseProps, PdfGProps, PdfImageProps, PdfImageSource, PdfLineProps, PdfLinearGradientProps, PdfLinkProps, PdfNoteProps, PdfPageDimension, PdfPageProps, PdfPageSize, PdfPageSizeName, PdfPageUnit, PdfPathProps, PdfPolygonProps, PdfPolylineProps, PdfRadialGradientProps, PdfRectProps, PdfStopProps, PdfSvgLength, PdfSvgNumber, PdfSvgPresentationProps, PdfSvgProps, PdfSvgTransform, PdfSvgTransformOperation, PdfTextProps, PdfTspanProps, PdfViewProps } from '../dist/runtime/components/index.js';
+
+interface ModuleOptions {
+    fonts?: readonly PdfFontDeclaration[];
+    remote?: RemoteAssetOptions;
+    /**
+     * Canonical render, tree, image, remote-request, and output budgets. Every
+     * field is an optional positive safe integer; omitted fields use the
+     * documented built-in defaults.
+     */
+    limits?: PdfLimitsOptions;
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+export { _default as default };
+export type { ModuleOptions };

package/dist/module.json

@@ -0,0 +1,12 @@
+{
+  "name": "nuxt-pdf",
+  "configKey": "pdf",
+  "compatibility": {
+    "nuxt": "^4.4.8"
+  },
+  "version": "0.3.0",
+  "builder": {
+    "@nuxt/module-builder": "1.0.2",
+    "unbuild": "unknown"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,368 @@
+import { stat } from 'node:fs/promises';
+import { join, isAbsolute, resolve } from 'node:path';
+import { defineNuxtModule, createResolver, getLayerDirectories, createIsIgnored, addServerTemplate, addTemplate, addImports, addTypeTemplate, addServerHandler } from '@nuxt/kit';
+import { d as discoverPdfTemplates, a as discoverPdfComponentFiles, b as discoverPdfImageFiles, c as bundlePdfFonts, e as createPdfSfcPlugin, f as classifyPdfWatchEvent } from './shared/nuxt-pdf.D2ZziYn4.mjs';
+import { Buffer } from 'node:buffer';
+import { joinURL } from 'ufo';
+import { normalizeRemoteAssetPolicy } from '../dist/runtime/server/assets/remote.js';
+import { loadPdfImageAsset } from '../dist/runtime/server/assets/resolve-asset.js';
+import { normalizePdfLimits, DEFAULT_PDF_RENDER_LIMITS } from '../dist/runtime/server/render-limits.js';
+import 'node:fs';
+import '@vue/compiler-sfc';
+import '@jridgewell/remapping';
+import 'esbuild';
+import 'unimport';
+import '../dist/runtime/shared/template.js';
+
+const compareText = (left, right) => {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+};
+const quote$1 = (value) => JSON.stringify(value);
+const generatePdfPreviewConfig = (baseURL, buildAssetsDir) => `export const hmrClientPath = ${quote$1(joinURL(
+  baseURL.replace(/^\.\//, "/") || "/",
+  buildAssetsDir,
+  "@vite/client"
+))}
+`;
+const importPath = (filePath) => filePath.replaceAll("\\", "/");
+const runtimeOptionsSource = (options) => {
+  const assets = options.assets ?? [];
+  const fonts = options.fonts ?? [];
+  const { remote, limits } = options;
+  if (assets.length === 0 && fonts.length === 0 && !remote && !limits) return [];
+  const lines = ["", "const __pdfRuntimeOptions = Object.freeze({"];
+  if (assets.length > 0) {
+    lines.push("  assets: Object.freeze({");
+    for (const asset of assets) {
+      lines.push(
+        `    ${quote$1(asset.key)}: Object.freeze({ data: __pdfBuffer.from(${quote$1(Buffer.from(asset.data).toString("base64"))}, 'base64'), format: ${quote$1(asset.format)} }),`
+      );
+    }
+    lines.push("  }),");
+  }
+  if (fonts.length > 0) {
+    lines.push("  fonts: Object.freeze([");
+    for (const font of fonts) {
+      lines.push(`    Object.freeze(${JSON.stringify(font)}),`);
+    }
+    lines.push("  ]),");
+  }
+  if (remote) {
+    lines.push(`  remote: Object.freeze(${JSON.stringify(remote)}),`);
+  }
+  if (limits) {
+    lines.push(`  limits: Object.freeze(${JSON.stringify(limits)}),`);
+  }
+  lines.push("})");
+  return lines;
+};
+const orderedTemplates = (templates) => {
+  const result = [...templates].sort(
+    (left, right) => compareText(left.key, right.key)
+  );
+  const keys = /* @__PURE__ */ new Map();
+  for (const template of result) {
+    const duplicate = keys.get(template.key);
+    if (duplicate) {
+      throw new TypeError(
+        `Cannot generate duplicate PDF template key "${template.key}" from "${duplicate.filePath}" and "${template.filePath}".`
+      );
+    }
+    keys.set(template.key, template);
+  }
+  return result;
+};
+const validateOptions = (options) => {
+  if (options.runtimeImport.trim() === "") {
+    throw new TypeError("runtimeImport is required to generate the PDF registry.");
+  }
+};
+const generatePdfRuntimeRegistry = (templates, options) => {
+  validateOptions(options);
+  const ordered = orderedTemplates(templates);
+  const runtimeImports = options.development ? "createPdfPreviewEntry, createPdfRegistry, createPdfTemplate" : "createPdfRegistry, createPdfTemplate";
+  const lines = [
+    `import { ${runtimeImports} } from ${quote$1(options.runtimeImport)}`
+  ];
+  if ((options.assets?.length ?? 0) > 0) {
+    lines.push("import { Buffer as __pdfBuffer } from 'node:buffer'");
+  }
+  ordered.forEach((template, index) => {
+    lines.push(
+      `import __pdfTemplate${index} from ${quote$1(importPath(template.filePath))}`
+    );
+  });
+  const runtimeOptions = runtimeOptionsSource(options);
+  lines.push(...runtimeOptions, "", "const registry = createPdfRegistry({");
+  ordered.forEach((template, index) => {
+    const file = quote$1(`pdfs/${template.relativePath}`);
+    const runtimeArgument = options.development ? runtimeOptions.length > 0 ? `, { ...__pdfRuntimeOptions, file: ${file} }` : `, { file: ${file} }` : runtimeOptions.length > 0 ? ", __pdfRuntimeOptions" : "";
+    lines.push(
+      `  ${quote$1(template.key)}: createPdfTemplate(${quote$1(template.key)}, __pdfTemplate${index}${runtimeArgument}),`
+    );
+  });
+  lines.push("})");
+  if (options.development) {
+    lines.push("", "export const pdfPreview = Object.freeze({");
+    ordered.forEach((template, index) => {
+      lines.push(
+        `  ${quote$1(template.key)}: createPdfPreviewEntry(registry.pdf[${quote$1(template.key)}], __pdfTemplate${index}, { file: ${quote$1(`pdfs/${template.relativePath}`)} }),`
+      );
+    });
+    lines.push("})");
+  }
+  lines.push(
+    "",
+    "export const pdf = registry.pdf",
+    "export const renderPdf = registry.renderPdf",
+    "export const getPdfTemplate = registry.getPdfTemplate",
+    "export const pdfTemplateKeys = registry.pdfTemplateKeys",
+    `export { NuxtPdfError, PDF_ERROR_CODES } from ${quote$1(options.runtimeImport)}`,
+    ""
+  );
+  return lines.join("\n");
+};
+const generatePdfRegistryTypes = (templates, options) => {
+  validateOptions(options);
+  const ordered = orderedTemplates(templates);
+  const lines = [
+    `import type { PdfComponentProps, PdfRenderResult, PdfTemplate } from ${quote$1(options.runtimeImport)}`
+  ];
+  ordered.forEach((template, index) => {
+    lines.push(
+      "",
+      `type PdfComponent${index} = typeof import(${quote$1(importPath(template.filePath))})['default']`,
+      `type PdfProps${index} = PdfComponentProps<PdfComponent${index}>`
+    );
+  });
+  lines.push("", "export declare const pdf: {");
+  ordered.forEach((template, index) => {
+    lines.push(
+      `  readonly ${quote$1(template.key)}: PdfTemplate<PdfProps${index}>`
+    );
+  });
+  lines.push("}", "");
+  if (ordered.length === 0) {
+    lines.push(
+      "export declare function renderPdf(name: never, props: never): Promise<PdfRenderResult>",
+      "export declare function getPdfTemplate(name: never): never"
+    );
+  } else {
+    ordered.forEach((template, index) => {
+      lines.push(
+        `export declare function renderPdf(name: ${quote$1(template.key)}, props: PdfProps${index}): Promise<PdfRenderResult>`
+      );
+    });
+    lines.push(
+      "export declare function renderPdf(name: string, props: Record<string, unknown>, escapeHatch: { readonly unsafe: true }): Promise<PdfRenderResult>"
+    );
+    lines.push("");
+    ordered.forEach((template, index) => {
+      lines.push(
+        `export declare function getPdfTemplate(name: ${quote$1(template.key)}): PdfTemplate<PdfProps${index}>`
+      );
+    });
+  }
+  lines.push(
+    "",
+    `export declare const pdfTemplateKeys: readonly [${ordered.map((template) => quote$1(template.key)).join(", ")}]`,
+    "export type PdfTemplateKey = typeof pdfTemplateKeys[number]",
+    `export { NuxtPdfError, PDF_ERROR_CODES } from ${quote$1(options.runtimeImport)}`,
+    `export type { PdfErrorCode } from ${quote$1(options.runtimeImport)}`,
+    ""
+  );
+  return lines.join("\n");
+};
+
+const quote = (value) => JSON.stringify(value);
+const existingDirectories = async (directories) => {
+  const result = [];
+  for (const directory of directories) {
+    try {
+      if ((await stat(directory)).isDirectory()) result.push(directory);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+  }
+  return result;
+};
+const generateAuthoringTypes = (componentsImport) => `declare module 'vue' {
+  interface GlobalComponents {
+    PdfDocument: typeof import(${quote(componentsImport)})['PdfDocument']
+    PdfImage: typeof import(${quote(componentsImport)})['PdfImage']
+    PdfLink: typeof import(${quote(componentsImport)})['PdfLink']
+    PdfNote: typeof import(${quote(componentsImport)})['PdfNote']
+    PdfPage: typeof import(${quote(componentsImport)})['PdfPage']
+    PdfText: typeof import(${quote(componentsImport)})['PdfText']
+    PdfView: typeof import(${quote(componentsImport)})['PdfView']
+    PdfSvg: typeof import(${quote(componentsImport)})['PdfSvg']
+    PdfG: typeof import(${quote(componentsImport)})['PdfG']
+    PdfPath: typeof import(${quote(componentsImport)})['PdfPath']
+    PdfRect: typeof import(${quote(componentsImport)})['PdfRect']
+    PdfCircle: typeof import(${quote(componentsImport)})['PdfCircle']
+    PdfEllipse: typeof import(${quote(componentsImport)})['PdfEllipse']
+    PdfLine: typeof import(${quote(componentsImport)})['PdfLine']
+    PdfPolyline: typeof import(${quote(componentsImport)})['PdfPolyline']
+    PdfPolygon: typeof import(${quote(componentsImport)})['PdfPolygon']
+    PdfDefs: typeof import(${quote(componentsImport)})['PdfDefs']
+    PdfClipPath: typeof import(${quote(componentsImport)})['PdfClipPath']
+    PdfLinearGradient: typeof import(${quote(componentsImport)})['PdfLinearGradient']
+    PdfRadialGradient: typeof import(${quote(componentsImport)})['PdfRadialGradient']
+    PdfStop: typeof import(${quote(componentsImport)})['PdfStop']
+    PdfTspan: typeof import(${quote(componentsImport)})['PdfTspan']
+  }
+}
+
+export {}
+`;
+const module$1 = defineNuxtModule({
+  meta: {
+    name: "nuxt-pdf",
+    configKey: "pdf",
+    compatibility: {
+      nuxt: "^4.4.8"
+    }
+  },
+  defaults: {
+    fonts: []
+  },
+  async setup(options, nuxt) {
+    const resolver = createResolver(import.meta.url);
+    const runtimeImport = resolver.resolve("./runtime/server/index");
+    const sharedImport = resolver.resolve("./runtime/shared/index");
+    const componentsImport = resolver.resolve("./runtime/components/index");
+    const composablesImport = resolver.resolve("./runtime/composables/index");
+    const definePdfImport = resolver.resolve("./runtime/define-pdf");
+    const previewHandler = resolver.resolve("./runtime/server/preview");
+    const layers = getLayerDirectories(nuxt).map(
+      (directories, index) => ({
+        rootDir: directories.root,
+        name: index === 0 ? "project" : `layer-${index}`
+      })
+    );
+    const isIgnored = createIsIgnored(nuxt);
+    const templates = await discoverPdfTemplates(layers, isIgnored);
+    const componentFiles = await discoverPdfComponentFiles(layers, isIgnored);
+    const limits = normalizePdfLimits(options.limits);
+    const resolvedLimits = limits ?? DEFAULT_PDF_RENDER_LIMITS;
+    const imageFiles = await discoverPdfImageFiles(layers, isIgnored);
+    const assets = await Promise.all(imageFiles.map(
+      (image) => loadPdfImageAsset(image.key, {
+        roots: [image.rootDir],
+        maxBytes: resolvedLimits.maxImageBytes,
+        maxPixels: resolvedLimits.maxImagePixels
+      })
+    ));
+    const fontRoots = await existingDirectories(
+      layers.map((layer) => join(layer.rootDir, "pdfs", "fonts"))
+    );
+    const remote = normalizeRemoteAssetPolicy(options.remote);
+    const fonts = await bundlePdfFonts(options.fonts ?? [], { fontRoots });
+    const pdfSfcFiles = new Map(
+      componentFiles.map((file) => [file, "component"])
+    );
+    for (const template of templates) {
+      pdfSfcFiles.set(template.filePath, "template");
+    }
+    for (const layer of layers) {
+      nuxt.options.watch.push(join(layer.rootDir, "pdfs"));
+    }
+    addServerTemplate({
+      filename: "#pdf",
+      getContents: () => generatePdfRuntimeRegistry(templates, {
+        assets,
+        development: nuxt.options.dev,
+        fonts,
+        remote,
+        limits,
+        runtimeImport
+      })
+    });
+    const registryTypeTemplate = addTemplate({
+      filename: "types/nuxt-pdf-registry.ts",
+      getContents: () => generatePdfRegistryTypes(templates, {
+        runtimeImport: sharedImport
+      }),
+      write: true
+    });
+    const addRegistryTypePath = (config) => {
+      const compilerOptions = config.compilerOptions ||= {};
+      const paths = compilerOptions.paths ||= {};
+      paths["#pdf"] = [registryTypeTemplate.dst];
+    };
+    nuxt.hook("prepare:types", ({ nodeTsConfig, tsConfig }) => {
+      addRegistryTypePath(tsConfig);
+      addRegistryTypePath(nodeTsConfig);
+    });
+    const nitroTypescript = nuxt.options.nitro.typescript ||= {};
+    const nitroTsConfig = nitroTypescript.tsConfig ||= {};
+    addRegistryTypePath(nitroTsConfig);
+    addImports({
+      name: "usePdfPageNumbers",
+      as: "usePdfPageNumbers",
+      from: composablesImport
+    });
+    addImports({
+      name: "definePdf",
+      as: "definePdf",
+      from: definePdfImport
+    });
+    addTypeTemplate({
+      filename: "types/nuxt-pdf-authoring.d.ts",
+      getContents: () => generateAuthoringTypes(
+        componentsImport
+      ),
+      write: true
+    }, { nitro: true, node: true, nuxt: true });
+    nuxt.hook("nitro:config", (nitroConfig) => {
+      const rollupConfig = nitroConfig.rollupConfig ||= {};
+      const existingPlugins = rollupConfig.plugins == null ? [] : Array.isArray(rollupConfig.plugins) ? rollupConfig.plugins : [rollupConfig.plugins];
+      rollupConfig.plugins = [
+        createPdfSfcPlugin({
+          files: pdfSfcFiles,
+          isProduction: !nuxt.options.dev,
+          composablesImport
+        }),
+        ...existingPlugins
+      ];
+    });
+    if (nuxt.options.dev) {
+      let clientViteServer;
+      nuxt.hook("vite:serverCreated", (viteServer, environment) => {
+        if (environment.isClient) clientViteServer = viteServer;
+      });
+      nuxt.hook("builder:watch", async (event, path) => {
+        const absolutePath = isAbsolute(path) ? path : resolve(nuxt.options.srcDir, path);
+        const action = classifyPdfWatchEvent(
+          event,
+          absolutePath,
+          layers,
+          isIgnored
+        );
+        if (action === "restart") {
+          await nuxt.callHook("restart");
+          return;
+        }
+        if (action !== "refresh") return;
+        clientViteServer?.ws.send({
+          type: "custom",
+          event: "nuxt-pdf:update",
+          data: {}
+        });
+      });
+      addServerTemplate({
+        filename: "#pdf-preview-config",
+        getContents: () => generatePdfPreviewConfig(
+          nuxt.options.app.baseURL,
+          nuxt.options.app.buildAssetsDir
+        )
+      });
+      addServerHandler({ route: "/_pdf", handler: previewHandler });
+      addServerHandler({ route: "/_pdf/**", handler: previewHandler });
+    }
+  }
+});
+
+export { module$1 as default };