@lupinum/nuxt-pdf 0.3.1 → 0.4.0-beta.2

package/dist/runtime/server/assets/resolve-asset.js

@@ -72,6 +72,12 @@ const formatFromExtension = (key) => {
   if (extension === ".jpg" || extension === ".jpeg") return "jpg";
   return invalid("PDF images must be PNG or JPEG files.");
 };
+export const pdfImageFormatFromKey = (key) => {
+  const extension = extname(key).toLowerCase();
+  if (extension === ".png") return "png";
+  if (extension === ".jpg" || extension === ".jpeg") return "jpg";
+  throw new TypeError(`PDF images must be PNG or JPEG files: "${key}".`);
+};
 const claimedFormat = (value) => {
   if (value === void 0) return void 0;
   if (typeof value !== "string") {
@@ -270,7 +276,30 @@ export const loadPdfImageAsset = async (relativePath, options) => {
     "The local PDF image was not found in a configured asset root."
   );
 };
-const resolveLocalImage = (source, assets, maxBytes, maxPixels, declaredFormat) => {
+const RESOLVED_IMAGE_CACHE_BYTES = 32 * 1024 * 1024;
+const resolvedImageCache = /* @__PURE__ */ new Map();
+let resolvedImageCacheBytes = 0;
+const embeddedImageCache = /* @__PURE__ */ new WeakMap();
+const rememberResolvedImage = (cacheKey, image) => {
+  if (resolvedImageCache.has(cacheKey)) return;
+  resolvedImageCache.set(cacheKey, image);
+  resolvedImageCacheBytes += image.data.byteLength;
+  while (resolvedImageCacheBytes > RESOLVED_IMAGE_CACHE_BYTES && resolvedImageCache.size > 1) {
+    const oldest = resolvedImageCache.keys().next().value;
+    if (oldest === void 0) break;
+    resolvedImageCacheBytes -= resolvedImageCache.get(oldest).data.byteLength;
+    resolvedImageCache.delete(oldest);
+  }
+};
+const cachedResolvedImage = (cacheKey) => {
+  const cached = resolvedImageCache.get(cacheKey);
+  if (!cached) return void 0;
+  return {
+    ...cached,
+    data: Buffer.from(cached.data)
+  };
+};
+const resolveLocalImage = async (source, assets, maxBytes, maxPixels, declaredFormat) => {
   const key = canonicalAssetKey(source);
   const pathFormat = formatFromExtension(key);
   const sourceFormat = claimedFormat(declaredFormat);
@@ -279,20 +308,66 @@ const resolveLocalImage = (source, assets, maxBytes, maxPixels, declaredFormat)
   }
   if (!hasOwn(assets, key)) {
     return invalid(
-      "The local PDF image was not included in the generated asset map."
+      `The local PDF image "${key}" was not found under pdfs/assets. Add the file or fix the path.`
     );
   }
-  const asset = assets[key];
-  if (!asset || typeof asset !== "object") {
+  const entry = assets[key];
+  if (!entry || typeof entry !== "object") {
     return invalid("The generated PDF image asset is invalid.");
   }
-  const assetFormat = claimedFormat(asset.format);
+  const assetFormat = claimedFormat(entry.format);
   if (!assetFormat || assetFormat !== pathFormat) {
     return invalid(
       "The generated PDF image format does not match its asset key."
     );
   }
-  return validateImageBytes(asset.data, maxBytes, assetFormat, maxPixels);
+  if ("dataB64" in entry) {
+    const limitsKey = `${maxBytes}\0${maxPixels}`;
+    let byLimits = embeddedImageCache.get(entry);
+    if (!byLimits) {
+      byLimits = /* @__PURE__ */ new Map();
+      embeddedImageCache.set(entry, byLimits);
+    }
+    const cached2 = byLimits.get(limitsKey);
+    if (cached2) return { ...cached2, data: Buffer.from(cached2.data) };
+    const resolved2 = validateImageBytes(
+      Buffer.from(entry.dataB64, "base64"),
+      maxBytes,
+      assetFormat,
+      maxPixels
+    );
+    byLimits.set(limitsKey, resolved2);
+    return { ...resolved2, data: Buffer.from(resolved2.data) };
+  }
+  let fileStat;
+  try {
+    fileStat = await stat(resolve(entry.root, ...key.split("/")));
+  } catch (error) {
+    if (isMissingFileError(error)) {
+      return invalid(`The local PDF image "${key}" was not found under pdfs/assets.`);
+    }
+    return invalid("The local PDF image cannot be inspected.", error);
+  }
+  if (!fileStat.isFile()) {
+    return invalid("The local PDF image is not a regular file.");
+  }
+  const cacheKey = `disk\0${key}\0${fileStat.mtimeMs}\0${fileStat.size}\0${maxBytes}\0${maxPixels}`;
+  const cached = cachedResolvedImage(cacheKey);
+  if (cached) return cached;
+  const loaded = await loadPdfImageAsset(key, {
+    roots: [entry.root],
+    maxBytes,
+    maxPixels
+  });
+  const resolved = Object.freeze({
+    data: loaded.data,
+    format: assetFormat,
+    height: loaded.height,
+    pixels: loaded.pixels,
+    width: loaded.width
+  });
+  rememberResolvedImage(cacheKey, resolved);
+  return { ...resolved, data: Buffer.from(resolved.data) };
 };
 const isRemoteCandidate = (source) => /^https?:/i.test(source);
 const imageResolutionCacheKey = (source) => {
@@ -443,12 +518,10 @@ export const resolvePdfImageAssets = async (document, options) => {
     if (hasOwn(node.props, "srcSet") && node.props.srcSet !== void 0) {
       return blocked("PDF image srcSet sources are blocked.");
     }
-    const hasSrc = hasOwn(node.props, "src") && node.props.src !== void 0;
-    const hasSource = hasOwn(node.props, "source") && node.props.source !== void 0;
-    if (hasSrc === hasSource) {
-      return invalid("Each PDF image must have exactly one src or source prop.");
+    if (!hasOwn(node.props, "src") || node.props.src === void 0) {
+      return invalid("Each PDF image must have a src prop.");
     }
-    targets.push({ node, prop: hasSrc ? "src" : "source" });
+    targets.push({ node });
   }
   if (targets.length > limits.maxImages) {
     return imageLimitExceeded(
@@ -459,7 +532,7 @@ export const resolvePdfImageAssets = async (document, options) => {
   try {
     resolved = await Promise.all(targets.map(
       (target) => resolveImageBuffer(
-        target.node.props[target.prop],
+        target.node.props.src,
         options.assets,
         limits,
         options.remote,
@@ -475,7 +548,7 @@ export const resolvePdfImageAssets = async (document, options) => {
   }
   targets.forEach((target, index) => {
     const data = resolved[index];
-    target.node.props[target.prop] = data;
+    target.node.props.src = data;
     state.resolved.set(data, Promise.resolve(data));
   });
   return document;

package/dist/runtime/server/engine/fonts.d.ts

@@ -5,4 +5,5 @@ export type PdfFontStore = {
     readonly [pdfFontStoreBrand]: true;
 };
 export declare const createPdfFontStore: (fonts?: readonly BundledPdfFontDescriptor[]) => PdfFontStore;
+export declare const getSharedPdfFontStore: (fonts?: readonly BundledPdfFontDescriptor[]) => PdfFontStore;
 export {};

package/dist/runtime/server/engine/fonts.js

@@ -1,5 +1,5 @@
 import FontStore from "@react-pdf/font";
-const isBundledFontSource = (src) => /^data:font\/(?:otf|ttf);base64,[A-Za-z0-9+/]+={0,2}$/.test(src);
+const isBundledFontSource = (src) => /^data:font\/(?:otf|ttf|woff2);base64,[A-Za-z0-9+/]+={0,2}$/.test(src);
 export const createPdfFontStore = (fonts = []) => {
   const fontStore = new FontStore();
   for (const font of fonts) {
@@ -17,3 +17,16 @@ export const createPdfFontStore = (fonts = []) => {
   }
   return fontStore;
 };
+const sameFontList = (left, right) => left.length === right.length && left.every((font, index) => {
+  const other = right[index];
+  return font.family === other.family && font.src === other.src && font.fontStyle === other.fontStyle && font.fontWeight === other.fontWeight;
+});
+let sharedFontStore;
+export const getSharedPdfFontStore = (fonts = []) => {
+  if (sharedFontStore && sameFontList(sharedFontStore.fonts, fonts)) {
+    return sharedFontStore.store;
+  }
+  const store = createPdfFontStore(fonts);
+  sharedFontStore = { fonts, store };
+  return store;
+};

package/dist/runtime/server/engine/render-document.d.ts

@@ -1,5 +1,6 @@
 import { type DocumentNode, type SafeDocumentNode } from '@react-pdf/layout';
 import { type PdfFontStore } from './fonts.js';
+import type { PdfLayoutWarning } from '../../shared/template.js';
 import { type RenderLimits } from '../render-limits.js';
 export interface PdfEngineOptions {
     compress?: boolean;
@@ -16,6 +17,12 @@ type DocumentMetadata = DocumentNode['props'];
 export declare const layoutPdfTree: (document: DocumentNode, fontStore: PdfFontStore, limits?: RenderLimits) => Promise<SafeDocumentNode>;
 /** The number of laid-out pages in a serialized document. */
 export declare const countPages: (layout: SafeDocumentNode) => number;
+/**
+ * Find blocks that cannot fit on any ordinary page because pagination is not
+ * allowed to split them. No text, ids, or other authored content enters the
+ * public diagnostics object.
+ */
+export declare const collectLayoutWarnings: (layout: SafeDocumentNode) => PdfLayoutWarning[];
 /**
  * Map every `id` (named destination) to the **first** 1-based page it appears
  * on. `id` is the key `render/src/operations/setDestination.ts` emits and that a

package/dist/runtime/server/engine/render-document.js

@@ -12,6 +12,7 @@ import {
 import {
   PDF_PRIMITIVES
 } from "../../authoring.js";
+import { PDF_PRIMITIVE_NAMES } from "../../renderer/index.js";
 import {
   enforceMaxPages
 } from "../render-limits.js";
@@ -117,6 +118,52 @@ const visitPageNodes = (page, visit) => {
 };
 const documentPages = (layout) => layout.children ?? [];
 export const countPages = (layout) => documentPages(layout).length;
+const NON_WRAPPING_NODE_TYPES = /* @__PURE__ */ new Set([
+  PDF_PRIMITIVES.Image,
+  PDF_PRIMITIVES.Note,
+  PDF_PRIMITIVES.Svg
+]);
+const WARNING_NODE_TYPES = /* @__PURE__ */ new Set([
+  PDF_PRIMITIVES.Image,
+  PDF_PRIMITIVES.Link,
+  PDF_PRIMITIVES.Note,
+  PDF_PRIMITIVES.Svg,
+  PDF_PRIMITIVES.Text,
+  PDF_PRIMITIVES.View
+]);
+const finiteNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+const roundedPoints = (value) => Math.round(value * 100) / 100;
+const pageContentHeight = (page) => {
+  const style = page.style;
+  const pageHeight = finiteNumber(style?.height) ?? finiteNumber(page.box.height);
+  if (pageHeight === void 0) return void 0;
+  const paddingTop = finiteNumber(page.box.paddingTop) ?? finiteNumber(style?.paddingTop) ?? 0;
+  const paddingBottom = finiteNumber(page.box.paddingBottom) ?? finiteNumber(style?.paddingBottom) ?? 0;
+  return pageHeight - paddingTop - paddingBottom;
+};
+const cannotWrap = (node) => NON_WRAPPING_NODE_TYPES.has(node.type) || node.props.wrap === false;
+export const collectLayoutWarnings = (layout) => {
+  const warnings = [];
+  documentPages(layout).forEach((pageNode, pageIndex) => {
+    if (!("props" in pageNode)) return;
+    const page = pageNode;
+    const availableHeight = pageContentHeight(page);
+    if (availableHeight === void 0 || availableHeight <= 0) return;
+    visitPageNodes(page, (node) => {
+      if (node === page || node.props.fixed === true || !WARNING_NODE_TYPES.has(node.type) || !cannotWrap(node)) return;
+      const nodeHeight = finiteNumber(node.box.height);
+      if (nodeHeight === void 0 || nodeHeight <= availableHeight + 1e-3) return;
+      warnings.push({
+        code: "PDF_UNBREAKABLE_NODE_OVERFLOW",
+        pageNumber: pageIndex + 1,
+        nodeType: PDF_PRIMITIVE_NAMES[node.type],
+        nodeHeight: roundedPoints(nodeHeight),
+        availableHeight: roundedPoints(availableHeight)
+      });
+    });
+  });
+  return warnings;
+};
 const nodeId = (node) => {
   const id = node.props?.id;
   return typeof id === "string" && id.length > 0 ? id : void 0;

package/dist/runtime/server/index.d.ts

@@ -2,4 +2,4 @@ export { createPdfPreviewEntry, createPdfRegistry, createPdfTemplate, } from './
 export { NuxtPdfError, PDF_ERROR_CODES, } from '../shared/errors.js';
 export type { PdfErrorCode } from '../shared/errors.js';
 export type { PdfPreviewEntry, PdfPreviewEntryOptions, PdfRegistry, PdfRegistryEntries, } from './registry.js';
-export type { PdfRenderDiagnostics, PdfRenderResult, PdfComponentProps, PdfTemplate, } from '../shared/template.js';
+export type { PdfLayoutWarning, PdfRenderDiagnostics, PdfRenderResult, PdfComponentProps, PdfTemplate, } from '../shared/template.js';

package/dist/runtime/server/preview.js

@@ -99,6 +99,10 @@ const htmlResponse = (title, content, status = 200) => new Response(`<!doctype h
       .font-faces .label { color: #8b948b; font-size: 0.78rem; letter-spacing: 0.04em; text-transform: uppercase; margin-bottom: 8px; }
       .font-faces ul { list-style: none; margin: 0; padding: 0; display: grid; gap: 6px; }
       .font-faces li { color: #d7ddd7; font-size: 0.85rem; line-height: 1.5; }
+      .layout-warnings { border: 1px solid #765b23; background: #211b0f; border-left: 3px solid #e2b653; border-radius: 10px; padding: 12px 16px; margin-bottom: 16px; }
+      .layout-warnings .label { color: #e8c977; font-size: 0.78rem; letter-spacing: 0.04em; text-transform: uppercase; margin-bottom: 8px; }
+      .layout-warnings ul { margin: 0; padding-left: 20px; display: grid; gap: 6px; }
+      .layout-warnings li { color: #f0dfb2; font-size: 0.85rem; line-height: 1.5; }
       .error { border: 1px solid #6b2f2b; background: #1d1210; border-left: 3px solid #ef786f; border-radius: 10px; padding: 18px 20px; }
       .error h2 { margin: 0 0 12px; font-size: 1.1rem; color: #f3d7d3; }
       .error dl { display: grid; grid-template-columns: max-content 1fr; gap: 6px 16px; margin: 0 0 12px; }
@@ -127,7 +131,7 @@ const indexPage = (registry, rootPath) => {
   if (templates.length === 0) {
     return htmlResponse(
       "PDF templates",
-      "<header><h1>PDF templates</h1></header><p>No templates found. Add <code>pdfs/invoice.vue</code> and restart the development server.</p>"
+      "<header><h1>PDF templates</h1></header><p>No templates found. Add <code>pdfs/invoice.vue</code>; Nuxt PDF restarts and registers it automatically.</p>"
     );
   }
   const cards = templates.map((template) => {
@@ -173,13 +177,17 @@ const diagnosticsPanel = (diagnostics) => {
     stat("Size", formatBytes(diagnostics.byteLength)),
     stat("Pages", String(diagnostics.pageCount)),
     stat("Layout passes", String(diagnostics.passes)),
+    stat("Layout warnings", String(diagnostics.layoutWarnings.length)),
     stat("Font faces", String(diagnostics.registeredFontFaces.length))
   ].join("");
+  const warnings = diagnostics.layoutWarnings.length > 0 ? `<div class="layout-warnings"><div class="label">Layout warnings</div><ul>${diagnostics.layoutWarnings.map(
+    (warning) => `<li><strong>${escapeHtml(warning.nodeType)}</strong> on page ${warning.pageNumber} is ${warning.nodeHeight} pt tall, but only ${warning.availableHeight} pt is available. Allow it to wrap or make it smaller.</li>`
+  ).join("")}</ul></div>` : "";
   const fonts = diagnostics.registeredFontFaces.length > 0 ? `<div class="font-faces"><div class="label">Registered font faces</div><ul>${diagnostics.registeredFontFaces.map((face) => {
     const attributes = [face.fontWeight, face.fontStyle].filter((value) => value !== void 0);
     return `<li>${escapeHtml(face.family)}${attributes.length > 0 ? ` \u2014 ${escapeHtml(attributes.join(" "))}` : ""}</li>`;
   }).join("")}</ul></div>` : "";
-  return `<div class="diagnostics">${stats}</div>${fonts}`;
+  return `<div class="diagnostics">${stats}</div>${warnings}${fonts}`;
 };
 const errorDetails = (error, fallbackKey, fallbackFile) => {
   const code = error instanceof NuxtPdfError ? error.code : "PDF_RENDER_ERROR";
@@ -225,7 +233,7 @@ const viewerPage = async (template, props, rootPath, scenario, hmrClientPath2 =
   }
   return htmlResponse(
     title,
-    `<header><h1>${escapeHtml(title)}</h1>${actions}</header>${nav}${body}<script type="module">import { createHotContext } from ${JSON.stringify(hmrClientPath2)};createHotContext('/_pdf').on('nuxt-pdf:update',()=>location.reload());<\/script>`
+    `<header><h1>${escapeHtml(title)}</h1>${actions}</header>${nav}${body}<script type="module">import { createHotContext } from ${JSON.stringify(hmrClientPath2)};createHotContext('/_pdf').on('nuxt-pdf:update',()=>{const frame=document.querySelector('iframe');if(frame&&frame.contentWindow){frame.contentWindow.location.reload();}else{location.reload();}});<\/script>`
   );
 };
 export const renderPdfPreview = async (registry, request = {}) => {

package/dist/runtime/server/registry.d.ts

@@ -4,7 +4,7 @@ import { type PdfImageAssetMap } from './assets/resolve-asset.js';
 import type { RemoteAssetPolicy } from './assets/remote.js';
 import { type PdfRenderLimits } from './render-limits.js';
 import type { BundledPdfFontDescriptor } from '../fonts.js';
-export type { PdfRenderDiagnostics } from '../shared/template.js';
+export type { PdfLayoutWarning, PdfRenderDiagnostics, } from '../shared/template.js';
 export interface PdfTemplateRuntimeOptions {
     assets?: PdfImageAssetMap;
     file?: string;

package/dist/runtime/server/registry.js

@@ -10,14 +10,18 @@ import {
   createPdfImageResolutionState,
   resolvePdfImageAssets
 } from "./assets/resolve-asset.js";
-import { countPages, renderDocument } from "./engine/render-document.js";
+import {
+  collectLayoutWarnings,
+  countPages,
+  renderDocument
+} from "./engine/render-document.js";
 import { renderDocumentMultiPass } from "./engine/layout-passes.js";
 import {
   createRenderLimits,
   enforceTreeLimits,
   resolvePdfRenderLimits
 } from "./render-limits.js";
-import { createPdfFontStore } from "./engine/fonts.js";
+import { getSharedPdfFontStore } from "./engine/fonts.js";
 import { createPdfRenderResult } from "./result.js";
 const EMPTY_SCENARIOS = Object.freeze({});
 const EMPTY_ASSETS = Object.freeze({});
@@ -123,7 +127,7 @@ const renderTemplate = async (component, props, metadata, options, maxPasses, li
       component,
       props
     );
-    const fontStore = createPdfFontStore(options.fonts);
+    const fontStore = getSharedPdfFontStore(options.fonts);
     if (mounted.usesPageNumbers) {
       const live = mounted;
       const result2 = await renderDocumentMultiPass(
@@ -140,6 +144,7 @@ const renderTemplate = async (component, props, metadata, options, maxPasses, li
       );
       return {
         bytes: result2.bytes,
+        layoutWarnings: collectLayoutWarnings(result2.layout),
         metadata: completedMetadata(live.document, metadata),
         passes: result2.passes,
         pageCount: countPages(result2.layout)
@@ -150,6 +155,7 @@ const renderTemplate = async (component, props, metadata, options, maxPasses, li
     const result = await renderDocument(document, { fontStore, limits });
     return {
       bytes: result.bytes,
+      layoutWarnings: collectLayoutWarnings(result.layout),
       metadata: completedMetadata(mounted.document, metadata),
       passes: 1,
       pageCount: countPages(result.layout)
@@ -176,6 +182,7 @@ export const createPdfTemplate = (key, component, options = {}) => {
     const definitionMetadata = resolveMetadata(ref, definition, props);
     const {
       bytes,
+      layoutWarnings,
       metadata,
       passes,
       pageCount
@@ -189,6 +196,7 @@ export const createPdfTemplate = (key, component, options = {}) => {
     );
     const result = createPdfRenderResult(bytes, metadata, {
       durationMs: performance.now() - start,
+      layoutWarnings,
       pageCount,
       passes,
       registeredFontFaces: (options.fonts ?? []).map((font) => ({

package/dist/runtime/server/result.js

@@ -43,6 +43,7 @@ export const createPdfRenderResult = (source, metadata, diagnostics) => {
   const completedDiagnostics = Object.freeze({
     byteLength: bytes.byteLength,
     durationMs: diagnostics.durationMs,
+    layoutWarnings: Object.freeze(diagnostics.layoutWarnings.map((warning) => Object.freeze({ ...warning }))),
     pageCount: diagnostics.pageCount,
     passes: diagnostics.passes,
     registeredFontFaces: Object.freeze(diagnostics.registeredFontFaces.map((face) => Object.freeze({ ...face })))

package/dist/runtime/shared/index.d.ts

@@ -1,4 +1,4 @@
 export { NuxtPdfError, PDF_ERROR_CODES, } from './errors.js';
 export type { NuxtPdfErrorOptions, PdfErrorCode, } from './errors.js';
 export { PDF_DEFINITION_PROPERTY, } from './template.js';
-export type { PdfComponent, PdfComponentProps, PdfDefinition, PdfDisposition, PdfMetadataValue, PdfRenderDiagnostics, PdfRenderResult, PdfResponseInit, PdfTemplate, ResolvedPdfMetadata, } from './template.js';
+export type { PdfComponent, PdfComponentProps, PdfDefinition, PdfDisposition, PdfLayoutWarning, PdfMetadataValue, PdfRenderDiagnostics, PdfRenderResult, PdfResponseInit, PdfTemplate, ResolvedPdfMetadata, } from './template.js';

package/dist/runtime/shared/template.d.ts

@@ -41,8 +41,16 @@ export interface PdfRenderDiagnostics {
     readonly byteLength: number;
     readonly pageCount: number;
     readonly passes: number;
+    readonly layoutWarnings: readonly PdfLayoutWarning[];
     readonly registeredFontFaces: readonly PdfRegisteredFontFace[];
 }
+export interface PdfLayoutWarning {
+    readonly code: 'PDF_UNBREAKABLE_NODE_OVERFLOW';
+    readonly pageNumber: number;
+    readonly nodeType: 'PdfImage' | 'PdfLink' | 'PdfNote' | 'PdfSvg' | 'PdfText' | 'PdfView';
+    readonly nodeHeight: number;
+    readonly availableHeight: number;
+}
 export interface PdfRegisteredFontFace {
     readonly family: string;
     readonly fontStyle?: string;

package/dist/shared/{nuxt-pdf.D2ZziYn4.mjs → nuxt-pdf.D0zmsct0.mjs}

@@ -22,7 +22,7 @@ const classifyPdfWatchEvent = (event, absolutePath, layers, isIgnored) => {
     if (PDF_STRUCTURE_EVENTS.has(event)) return "restart";
     if (event !== "change") return "ignore";
     const [rootDirectory] = pathWithinPdfs.split(/[\\/]/);
-    return rootDirectory === "assets" || rootDirectory === "fonts" ? "restart" : "refresh";
+    return rootDirectory === "fonts" ? "restart" : "refresh";
   }
   return "ignore";
 };
@@ -185,6 +185,7 @@ const discoverPdfImageFiles = async (layers, isIgnored) => {
 };
 
 const DEFAULT_MAX_PDF_FONT_BYTES = 5 * 1024 * 1024;
+const DEFAULT_MAX_PDF_DECOMPRESSED_FONT_BYTES = 20 * 1024 * 1024;
 const FONT_WEIGHT_VALUES = {
   black: 900,
   bold: 700,
@@ -347,13 +348,53 @@ const validateDeclaration = (declaration) => {
   };
 };
 const detectFontFormat = (bytes) => {
-  if (bytes.byteLength < 12) return void 0;
+  if (bytes.byteLength < 4) return void 0;
   const isTrueType = bytes[0] === 0 && bytes[1] === 1 && bytes[2] === 0 && bytes[3] === 0;
   const isOpenType = bytes[0] === 79 && bytes[1] === 84 && bytes[2] === 84 && bytes[3] === 79;
+  const isWoff2 = bytes[0] === 119 && bytes[1] === 79 && bytes[2] === 70 && bytes[3] === 50;
   if (isTrueType) return "ttf";
   if (isOpenType) return "otf";
+  if (isWoff2) return "woff2";
   return void 0;
 };
+const validateWoff2Structure = (source, bytes) => {
+  if (bytes.byteLength < 48) {
+    throw fontError(source, "the WOFF2 header is corrupt or truncated.");
+  }
+  const data = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const flavor = data.readUInt32BE(4);
+  const declaredLength = data.readUInt32BE(8);
+  const tableCount = data.readUInt16BE(12);
+  const reserved = data.readUInt16BE(14);
+  const decompressedSize = data.readUInt32BE(16);
+  const compressedSize = data.readUInt32BE(20);
+  const isTrueType = flavor === 65536;
+  const isOpenType = flavor === 1330926671;
+  if (!isTrueType && !isOpenType) {
+    throw fontError(source, "the WOFF2 font must wrap a TTF or OTF font.");
+  }
+  if (declaredLength !== bytes.byteLength || tableCount < 1 || tableCount > 4096 || reserved !== 0 || compressedSize < 1 || compressedSize > bytes.byteLength - 48) {
+    throw fontError(source, "the WOFF2 header is corrupt or truncated.");
+  }
+  if (decompressedSize < 12 || decompressedSize > DEFAULT_MAX_PDF_DECOMPRESSED_FONT_BYTES) {
+    throw fontError(
+      source,
+      `the decompressed WOFF2 font exceeds the ${DEFAULT_MAX_PDF_DECOMPRESSED_FONT_BYTES}-byte limit.`
+    );
+  }
+  const metadataOffset = data.readUInt32BE(28);
+  const metadataLength = data.readUInt32BE(32);
+  const metadataOriginalLength = data.readUInt32BE(36);
+  const privateOffset = data.readUInt32BE(40);
+  const privateLength = data.readUInt32BE(44);
+  const metadataAbsent = metadataOffset === 0 && metadataLength === 0 && metadataOriginalLength === 0;
+  const metadataPresent = metadataOffset >= 48 && metadataLength > 0 && metadataOriginalLength > 0 && metadataOffset + metadataLength <= bytes.byteLength;
+  const privateAbsent = privateOffset === 0 && privateLength === 0;
+  const privatePresent = privateOffset >= 48 && privateLength > 0 && privateOffset + privateLength <= bytes.byteLength;
+  if (!metadataAbsent && !metadataPresent || !privateAbsent && !privatePresent) {
+    throw fontError(source, "the WOFF2 optional data blocks are corrupt.");
+  }
+};
 const validateSfntStructure = (source, bytes, format) => {
   const data = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
   const tableCount = data.readUInt16BE(4);
@@ -380,20 +421,21 @@ const validateSfntStructure = (source, bytes, format) => {
 };
 const fontFormat = (source, bytes) => {
   const extension = extname(source).toLowerCase();
-  if (extension !== ".otf" && extension !== ".ttf") {
-    throw fontError(source, "only .ttf and .otf files are supported.");
+  if (extension !== ".otf" && extension !== ".ttf" && extension !== ".woff2") {
+    throw fontError(source, "only .ttf, .otf, and .woff2 files are supported.");
   }
-  if (bytes.byteLength < 12) {
-    throw fontError(source, "the file is too small to be a TTF or OTF font.");
+  if (bytes.byteLength < 4) {
+    throw fontError(source, "the file is too small to be a supported font.");
   }
   const format = detectFontFormat(bytes);
   if (!format) {
-    throw fontError(source, "the file has an unsupported TTF or OTF signature.");
+    throw fontError(source, "the file has an unsupported font signature.");
   }
   if (`.${format}` !== extension) {
-    throw fontError(source, "the file extension does not match its TTF or OTF signature.");
+    throw fontError(source, "the file extension does not match its font signature.");
   }
-  validateSfntStructure(source, bytes, format);
+  if (format === "woff2") validateWoff2Structure(source, bytes);
+  else validateSfntStructure(source, bytes, format);
   return format;
 };
 const readFont = async (source, filePath, maxBytes) => {

package/dist/test.mjs

@@ -2,7 +2,7 @@ import { createRequire } from 'node:module';
 import { defineComponent, h } from 'vue';
 import { normalizeRemoteAssetPolicy } from '../dist/runtime/server/assets/remote.js';
 import { createPdfTemplate } from '../dist/runtime/server/registry.js';
-import { normalizePdfLimits, resolvePdfRenderLimits } from '../dist/runtime/server/render-limits.js';
+import { normalizePdfLimits } from '../dist/runtime/server/render-limits.js';
 import { PDF_DEFINITION_PROPERTY } from '../dist/runtime/shared/template.js';
 import { Buffer } from 'node:buffer';
 import { existsSync } from 'node:fs';
@@ -10,8 +10,8 @@ import { mkdir, writeFile, rm, readFile, readdir } from 'node:fs/promises';
 import { resolve, dirname, join, relative, basename } from 'node:path';
 import { pathToFileURL, fileURLToPath } from 'node:url';
 import { build } from 'esbuild';
-import { t as templateKeyFromRelativePath, b as discoverPdfImageFiles, c as bundlePdfFonts, g as compilePdfSfc } from './shared/nuxt-pdf.D2ZziYn4.mjs';
-import { loadPdfImageAsset } from '../dist/runtime/server/assets/resolve-asset.js';
+import { t as templateKeyFromRelativePath, b as discoverPdfImageFiles, c as bundlePdfFonts, g as compilePdfSfc } from './shared/nuxt-pdf.D0zmsct0.mjs';
+import { pdfImageFormatFromKey } from '../dist/runtime/server/assets/resolve-asset.js';
 import '@vue/compiler-sfc';
 import '@jridgewell/remapping';
 import 'unimport';
@@ -571,18 +571,15 @@ async function renderPdfSfc(filename, props, options = {}) {
     throw new Error(`PDF SFC ${JSON.stringify(entry)} must be a template directly inside pdfs/ or one of its feature directories.`);
   }
   const normalizedLimits = normalizePdfLimits(options.limits);
-  const limits = resolvePdfRenderLimits(normalizedLimits);
   const [component, imageFiles, fonts] = await Promise.all([
     loadPdfSfc(entry),
     discoverPdfImageFiles([{ name: "test", rootDir }]),
     bundlePdfFonts(options.fonts ?? [], { fontRoots: [join(rootDir, "pdfs", "fonts")] })
   ]);
-  const loadedAssets = await Promise.all(imageFiles.map((image) => loadPdfImageAsset(image.key, {
-    roots: [image.rootDir],
-    maxBytes: limits.maxImageBytes,
-    maxPixels: limits.maxImagePixels
-  })));
-  const assets = Object.fromEntries(loadedAssets.map((asset) => [asset.key, asset]));
+  const assets = Object.fromEntries(imageFiles.map((image) => [
+    image.key,
+    Object.freeze({ format: pdfImageFormatFromKey(image.key), root: image.rootDir })
+  ]));
   return renderPreparedPdfTemplate(component, props, {
     assets,
     file: `pdfs/${relativePath}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lupinum/nuxt-pdf",
-  "version": "0.3.1",
+  "version": "0.4.0-beta.2",
   "description": "Author and render PDFs with Vue components in Nuxt",
   "keywords": [
     "nuxt",
@@ -56,9 +56,10 @@
     "build": "nuxt prepare && nuxt-module-build build",
     "api:write": "node scripts/check-api-report.mjs --write",
     "changelog": "changelogen --no-output",
-    "docs:build": "pnpm build && pnpm --dir docs build",
+    "docs:build": "pnpm docs:theme && pnpm build && pnpm --dir docs build",
     "docs:build:vercel": "node scripts/build-docs-vercel.mjs",
     "docs:dev": "pnpm --dir docs dev",
+    "docs:theme": "node scripts/check-docs-theme.mjs",
     "format": "eslint . --fix",
     "format:check": "eslint .",
     "lint": "eslint .",
@@ -70,7 +71,7 @@
     "release:verify": "pnpm verify && pnpm release:pack",
     "test:artifact": "node scripts/check-release-artifact.mjs",
     "test:dependencies": "node scripts/check-production-dependencies.mjs",
-    "test:docs": "node scripts/check-documentation.mjs && pnpm --dir docs check",
+    "test:docs": "node scripts/check-documentation.mjs && pnpm docs:theme && pnpm --dir docs check",
     "test:package": "node scripts/check-package.mjs",
     "test:package-metadata": "node scripts/check-api-report.mjs",
     "test:performance": "node --expose-gc ./node_modules/vitest/vitest.mjs run --config vitest.performance.config.ts",
@@ -79,7 +80,7 @@
     "test:quickstart": "node scripts/test-package-quickstart.mjs",
     "test:raster": "vitest run --config vitest.raster.config.ts",
     "test:version-headings": "node scripts/check-version-headings.mjs",
-    "test:workflows": "node scripts/check-workflow-policy.mjs",
+    "test:workflows": "node scripts/check-workflow-policy.mjs && node scripts/test-npm-recovery.mjs && node scripts/test-release-recovery.mjs",
     "check:vercel": "node scripts/check-vercel-config.mjs",
     "test:serverless": "vitest run --config vitest.serverless.config.ts",
     "test:watch": "vitest watch",
@@ -139,6 +140,7 @@
     "typescript": "~5.9.3",
     "vitest": "^4.1.8",
     "vue": "3.5.40",
-    "vue-tsc": "^3.3.3"
+    "vue-tsc": "^3.3.3",
+    "yaml": "2.9.0"
   }
 }