@lupinum/nuxt-pdf 0.3.0

package/dist/runtime/server/registry.js

@@ -0,0 +1,270 @@
+import { mountPdfComponent } from "../renderer/index.js";
+import {
+  NuxtPdfError,
+  PDF_ERROR_CODES
+} from "../shared/errors.js";
+import {
+  PDF_DEFINITION_PROPERTY
+} from "../shared/template.js";
+import {
+  createPdfImageResolutionState,
+  resolvePdfImageAssets
+} from "./assets/resolve-asset.js";
+import { 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 { createPdfRenderResult } from "./result.js";
+const EMPTY_SCENARIOS = Object.freeze({});
+const EMPTY_ASSETS = Object.freeze({});
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const templateError = (ref, message, cause) => new NuxtPdfError(
+  PDF_ERROR_CODES.TemplateInvalid,
+  `Invalid ${templatePrefix(ref.key, ref.file)}: ${message}`,
+  { cause, templateKey: ref.key, templateFile: ref.file }
+);
+const templatePrefix = (key, file) => file === void 0 ? `PDF template "${key}"` : `PDF template "${key}" (${file})`;
+const enrichTemplateError = (error, key, file) => {
+  const prefix = templatePrefix(key, file);
+  if (error instanceof NuxtPdfError) {
+    if (error.templateKey === key) return error;
+    return new NuxtPdfError(error.code, `${prefix}: ${error.message}`, {
+      cause: error,
+      templateKey: key,
+      templateFile: file
+    });
+  }
+  return new NuxtPdfError(
+    PDF_ERROR_CODES.RenderError,
+    `${prefix}: ${error instanceof Error ? error.message : String(error)}`,
+    { cause: error, templateKey: key, templateFile: file }
+  );
+};
+const validateDefinition = (ref, definition) => {
+  if (!isObject(definition)) {
+    throw templateError(
+      ref,
+      "definePdf metadata is missing. Add one top-level definePdf({...}) call."
+    );
+  }
+  for (const field of ["title", "filename"]) {
+    const value = definition[field];
+    if (value !== void 0 && typeof value !== "string" && typeof value !== "function") {
+      throw templateError(ref, `${field} must be a string or function.`);
+    }
+  }
+  if (definition.language !== void 0 && typeof definition.language !== "string") {
+    throw templateError(ref, "language must be a string.");
+  }
+  const maxPasses = definition.maxPasses;
+  if (maxPasses !== void 0 && (typeof maxPasses !== "number" || !Number.isInteger(maxPasses) || maxPasses < 1)) {
+    throw templateError(ref, "maxPasses must be a positive integer.");
+  }
+  if (definition.sampleData !== void 0 && !isObject(definition.sampleData)) {
+    throw templateError(ref, "sampleData must be an object.");
+  }
+  if (definition.scenarios !== void 0) {
+    if (!isObject(definition.scenarios)) {
+      throw templateError(ref, "scenarios must be an object.");
+    }
+    for (const [name, props] of Object.entries(definition.scenarios)) {
+      if (!name || !isObject(props)) {
+        throw templateError(ref, `scenario "${name}" must contain a props object.`);
+      }
+    }
+  }
+  return definition;
+};
+const resolveMetadataValue = (ref, field, value, props) => {
+  let resolved;
+  try {
+    resolved = typeof value === "function" ? value(props) : value;
+  } catch (error) {
+    throw templateError(ref, `${field} metadata could not be evaluated.`, error);
+  }
+  if (resolved !== void 0 && typeof resolved !== "string") {
+    throw templateError(ref, `${field} metadata must resolve to a string.`);
+  }
+  return resolved;
+};
+const resolveMetadata = (ref, definition, props) => ({
+  title: resolveMetadataValue(ref, "title", definition.title, props),
+  filename: resolveMetadataValue(ref, "filename", definition.filename, props),
+  language: definition.language
+});
+const applyDocumentMetadata = (document, metadata) => {
+  if (metadata.title !== void 0) document.props.title = metadata.title;
+  if (metadata.language !== void 0) document.props.language = metadata.language;
+};
+const completedMetadata = (document, definition) => ({
+  filename: definition.filename,
+  language: typeof document.props.language === "string" ? document.props.language : void 0,
+  title: typeof document.props.title === "string" ? document.props.title : void 0
+});
+const renderTemplate = async (component, props, metadata, options, maxPasses, limits) => {
+  let mounted;
+  const imageState = createPdfImageResolutionState(limits);
+  const admitDocument = async (document) => {
+    enforceTreeLimits(document, limits);
+    applyDocumentMetadata(document, metadata);
+    await resolvePdfImageAssets(document, {
+      assets: options.assets ?? EMPTY_ASSETS,
+      limits,
+      remote: options.remote,
+      state: imageState
+    });
+  };
+  try {
+    mounted = await mountPdfComponent(
+      component,
+      props
+    );
+    const fontStore = createPdfFontStore(options.fonts);
+    if (mounted.usesPageNumbers) {
+      const live = mounted;
+      const result2 = await renderDocumentMultiPass(
+        {
+          get document() {
+            return live.document;
+          },
+          feed: async (pages) => {
+            await live.feedPageNumbers(pages);
+            await admitDocument(live.document);
+          }
+        },
+        { fontStore, maxPasses, limits }
+      );
+      return {
+        bytes: result2.bytes,
+        metadata: completedMetadata(live.document, metadata),
+        passes: result2.passes,
+        pageCount: countPages(result2.layout)
+      };
+    }
+    await admitDocument(mounted.document);
+    const document = mounted.document;
+    const result = await renderDocument(document, { fontStore, limits });
+    return {
+      bytes: result.bytes,
+      metadata: completedMetadata(mounted.document, metadata),
+      passes: 1,
+      pageCount: countPages(result.layout)
+    };
+  } finally {
+    mounted?.unmount();
+  }
+};
+export const createPdfTemplate = (key, component, options = {}) => {
+  const ref = { key, file: options.file };
+  if (!key.trim()) {
+    throw templateError(ref, "template key must not be empty.");
+  }
+  const definition = validateDefinition(
+    ref,
+    component[PDF_DEFINITION_PROPERTY]
+  );
+  const renderWithDiagnostics = async (props) => {
+    if (!isObject(props)) {
+      throw templateError(ref, "render props must be an object.");
+    }
+    const start = performance.now();
+    const limits = createRenderLimits(resolvePdfRenderLimits(options.limits));
+    const definitionMetadata = resolveMetadata(ref, definition, props);
+    const {
+      bytes,
+      metadata,
+      passes,
+      pageCount
+    } = await renderTemplate(
+      component,
+      props,
+      definitionMetadata,
+      options,
+      definition.maxPasses,
+      limits
+    );
+    const result = createPdfRenderResult(bytes, metadata, {
+      durationMs: performance.now() - start,
+      pageCount,
+      passes,
+      registeredFontFaces: (options.fonts ?? []).map((font) => ({
+        family: font.family,
+        fontStyle: font.fontStyle,
+        fontWeight: font.fontWeight
+      }))
+    });
+    return result;
+  };
+  return Object.freeze({
+    key,
+    resolveMetadata(props) {
+      if (!isObject(props)) {
+        throw templateError(ref, "metadata props must be an object.");
+      }
+      return resolveMetadata(ref, definition, props);
+    },
+    async render(props) {
+      try {
+        return await renderWithDiagnostics(props);
+      } catch (error) {
+        throw enrichTemplateError(error, key, options.file);
+      }
+    }
+  });
+};
+export const createPdfPreviewEntry = (template, component, options = {}) => {
+  const ref = { key: template.key, file: options.file };
+  const definition = validateDefinition(
+    ref,
+    component[PDF_DEFINITION_PROPERTY]
+  );
+  const scenarios = definition.scenarios ?? EMPTY_SCENARIOS;
+  const scenarioNames = Object.freeze(Object.keys(scenarios).sort());
+  return Object.freeze({
+    template,
+    file: options.file,
+    scenarioNames,
+    getPreviewProps(scenario) {
+      if (scenario === void 0) return definition.sampleData;
+      if (!Object.prototype.hasOwnProperty.call(scenarios, scenario)) {
+        return void 0;
+      }
+      return scenarios[scenario];
+    }
+  });
+};
+export const createPdfRegistry = (entries) => {
+  for (const [key, template] of Object.entries(entries)) {
+    if (!template?.key) {
+      throw new TypeError(`PDF registry entry "${key}" is invalid.`);
+    }
+    if (template.key !== key) {
+      throw new TypeError(
+        `PDF registry entry "${key}" must use the same key as createPdfTemplate ("${template.key}").`
+      );
+    }
+  }
+  const pdf = Object.freeze(entries);
+  const pdfTemplateKeys = Object.freeze(Object.keys(pdf));
+  const getTemplate = (key) => Object.hasOwn(pdf, key) ? pdf[key] : void 0;
+  return Object.freeze({
+    pdf,
+    pdfTemplateKeys,
+    getPdfTemplate: getTemplate,
+    async renderPdf(key, props) {
+      const template = getTemplate(key);
+      if (!template) {
+        throw new NuxtPdfError(
+          PDF_ERROR_CODES.TemplateNotFound,
+          `PDF template "${key}" was not found.`,
+          { templateKey: key }
+        );
+      }
+      return template.render(props);
+    }
+  });
+};

package/dist/runtime/server/render-limits.d.ts

@@ -0,0 +1,51 @@
+import type { PdfDocumentNode } from '../renderer/index.js';
+export declare const DEFAULT_PDF_TIMEOUT_MS = 30000;
+export declare const DEFAULT_PDF_MAX_PAGES = 2000;
+export declare const DEFAULT_PDF_MAX_NODES = 50000;
+export declare const DEFAULT_PDF_MAX_TREE_DEPTH = 128;
+export declare const DEFAULT_PDF_MAX_TEXT_CHARACTERS = 2000000;
+export declare const DEFAULT_PDF_MAX_IMAGES = 256;
+export declare const DEFAULT_PDF_MAX_IMAGE_BYTES: number;
+export declare const DEFAULT_PDF_MAX_TOTAL_IMAGE_BYTES: number;
+export declare const DEFAULT_PDF_MAX_IMAGE_PIXELS = 25000000;
+export declare const DEFAULT_PDF_MAX_TOTAL_IMAGE_PIXELS = 100000000;
+export declare const DEFAULT_PDF_MAX_REMOTE_REQUESTS = 32;
+export declare const DEFAULT_PDF_MAX_REMOTE_CONCURRENCY = 4;
+export declare const DEFAULT_PDF_MAX_OUTPUT_BYTES: number;
+/** Operator-facing `pdf.limits` module option. */
+export interface PdfLimitsOptions {
+    timeoutMs?: number;
+    maxPages?: number;
+    maxNodes?: number;
+    maxTreeDepth?: number;
+    maxTextCharacters?: number;
+    maxImages?: number;
+    maxImageBytes?: number;
+    maxTotalImageBytes?: number;
+    maxImagePixels?: number;
+    maxTotalImagePixels?: number;
+    maxRemoteRequests?: number;
+    maxRemoteConcurrency?: number;
+    maxOutputBytes?: number;
+}
+/** Fully resolved render limits threaded through the registry runtime options. */
+export type PdfRenderLimits = Required<PdfLimitsOptions>;
+export declare const DEFAULT_PDF_RENDER_LIMITS: Readonly<PdfRenderLimits>;
+/** A monotonic checked deadline shared by the whole render. */
+export interface RenderDeadline {
+    check(): void;
+    remainingMs(): number;
+}
+export declare const createRenderDeadline: (timeoutMs: number) => RenderDeadline;
+export declare const enforceMaxPages: (pageCount: number, maxPages: number) => void;
+/** Everything needed to enforce one render's resolved budgets. */
+export interface RenderLimits extends PdfRenderLimits {
+    readonly abortController: AbortController;
+    readonly deadline: RenderDeadline;
+}
+export declare const createRenderLimits: (limits: PdfRenderLimits) => RenderLimits;
+/** Fail before layout when the mounted canonical tree exceeds admission limits. */
+export declare const enforceTreeLimits: (document: PdfDocumentNode, limits: RenderLimits) => void;
+export declare const resolvePdfRenderLimits: (limits: PdfRenderLimits | undefined) => PdfRenderLimits;
+/** Validate operator limits once and fill every omitted field from one default. */
+export declare const normalizePdfLimits: (options: PdfLimitsOptions | undefined) => PdfRenderLimits | undefined;

package/dist/runtime/server/render-limits.js

@@ -0,0 +1,143 @@
+import { NuxtPdfError, PDF_ERROR_CODES } from "../shared/errors.js";
+import { PDF_PRIMITIVES } from "../authoring.js";
+export const DEFAULT_PDF_TIMEOUT_MS = 3e4;
+export const DEFAULT_PDF_MAX_PAGES = 2e3;
+export const DEFAULT_PDF_MAX_NODES = 5e4;
+export const DEFAULT_PDF_MAX_TREE_DEPTH = 128;
+export const DEFAULT_PDF_MAX_TEXT_CHARACTERS = 2e6;
+export const DEFAULT_PDF_MAX_IMAGES = 256;
+export const DEFAULT_PDF_MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+export const DEFAULT_PDF_MAX_TOTAL_IMAGE_BYTES = 32 * 1024 * 1024;
+export const DEFAULT_PDF_MAX_IMAGE_PIXELS = 25e6;
+export const DEFAULT_PDF_MAX_TOTAL_IMAGE_PIXELS = 1e8;
+export const DEFAULT_PDF_MAX_REMOTE_REQUESTS = 32;
+export const DEFAULT_PDF_MAX_REMOTE_CONCURRENCY = 4;
+export const DEFAULT_PDF_MAX_OUTPUT_BYTES = 64 * 1024 * 1024;
+export const DEFAULT_PDF_RENDER_LIMITS = Object.freeze({
+  timeoutMs: DEFAULT_PDF_TIMEOUT_MS,
+  maxPages: DEFAULT_PDF_MAX_PAGES,
+  maxNodes: DEFAULT_PDF_MAX_NODES,
+  maxTreeDepth: DEFAULT_PDF_MAX_TREE_DEPTH,
+  maxTextCharacters: DEFAULT_PDF_MAX_TEXT_CHARACTERS,
+  maxImages: DEFAULT_PDF_MAX_IMAGES,
+  maxImageBytes: DEFAULT_PDF_MAX_IMAGE_BYTES,
+  maxTotalImageBytes: DEFAULT_PDF_MAX_TOTAL_IMAGE_BYTES,
+  maxImagePixels: DEFAULT_PDF_MAX_IMAGE_PIXELS,
+  maxTotalImagePixels: DEFAULT_PDF_MAX_TOTAL_IMAGE_PIXELS,
+  maxRemoteRequests: DEFAULT_PDF_MAX_REMOTE_REQUESTS,
+  maxRemoteConcurrency: DEFAULT_PDF_MAX_REMOTE_CONCURRENCY,
+  maxOutputBytes: DEFAULT_PDF_MAX_OUTPUT_BYTES
+});
+export const createRenderDeadline = (timeoutMs) => {
+  const start = performance.now();
+  const remainingMs = () => Math.max(0, timeoutMs - (performance.now() - start));
+  return {
+    check() {
+      const elapsed = performance.now() - start;
+      if (elapsed > timeoutMs) {
+        throw new NuxtPdfError(
+          PDF_ERROR_CODES.LimitExceeded,
+          `PDF render exceeded its ${timeoutMs}ms time budget (elapsed ${Math.round(elapsed)}ms). Raise pdf.limits.timeoutMs if this document is legitimately this slow. The budget is checked between engine stages and passes, not mid-step, so a single layout stage can overshoot it.`
+        );
+      }
+    },
+    remainingMs
+  };
+};
+const limitExceeded = (message) => {
+  throw new NuxtPdfError(PDF_ERROR_CODES.LimitExceeded, message);
+};
+export const enforceMaxPages = (pageCount, maxPages) => {
+  if (pageCount > maxPages) {
+    limitExceeded(
+      `PDF laid out ${pageCount} pages, exceeding the ${maxPages}-page limit. Raise pdf.limits.maxPages if this document is legitimately this long.`
+    );
+  }
+};
+export const createRenderLimits = (limits) => ({
+  ...limits,
+  abortController: new AbortController(),
+  deadline: createRenderDeadline(limits.timeoutMs)
+});
+const textLength = (value) => {
+  let count = 0;
+  for (const _character of value) count += 1;
+  return count;
+};
+export const enforceTreeLimits = (document, limits) => {
+  const pending = [{
+    depth: 1,
+    node: document
+  }];
+  const seen = /* @__PURE__ */ new Set();
+  let images = 0;
+  let nodes = 0;
+  let textCharacters = 0;
+  while (pending.length > 0) {
+    const { depth, node } = pending.pop();
+    nodes += 1;
+    if (nodes > limits.maxNodes) {
+      limitExceeded(
+        `PDF mounted more than ${limits.maxNodes} nodes. Raise pdf.limits.maxNodes only for a legitimately larger document.`
+      );
+    }
+    if (depth > limits.maxTreeDepth) {
+      limitExceeded(
+        `PDF tree depth exceeded ${limits.maxTreeDepth}. Raise pdf.limits.maxTreeDepth only for a legitimately deeper document.`
+      );
+    }
+    if (node.type === PDF_PRIMITIVES.TextInstance) {
+      textCharacters += textLength(node.value);
+      if (textCharacters > limits.maxTextCharacters) {
+        limitExceeded(
+          `PDF text exceeded ${limits.maxTextCharacters} characters. Raise pdf.limits.maxTextCharacters only for legitimate content.`
+        );
+      }
+      continue;
+    }
+    if (seen.has(node)) {
+      throw new NuxtPdfError(
+        PDF_ERROR_CODES.TreeInvalid,
+        "PDF tree contains a repeated or circular element node."
+      );
+    }
+    seen.add(node);
+    if (node.type === PDF_PRIMITIVES.Image) {
+      images += 1;
+      if (images > limits.maxImages) {
+        limitExceeded(
+          `PDF mounted more than ${limits.maxImages} images. Raise pdf.limits.maxImages only for a legitimate document.`
+        );
+      }
+    }
+    for (let index = node.children.length - 1; index >= 0; index -= 1) {
+      const child = node.children[index];
+      if (child) pending.push({ depth: depth + 1, node: child });
+    }
+  }
+  limits.deadline.check();
+};
+export const resolvePdfRenderLimits = (limits) => ({
+  ...DEFAULT_PDF_RENDER_LIMITS,
+  ...limits
+});
+const validatePositiveSafeInteger = (value, key) => {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) {
+    throw new TypeError(`pdf.limits.${key} must be a positive safe integer.`);
+  }
+  return value;
+};
+export const normalizePdfLimits = (options) => {
+  if (options === void 0) return void 0;
+  if (options === null || typeof options !== "object" || Array.isArray(options)) {
+    throw new TypeError("pdf.limits must be an object.");
+  }
+  const result = { ...DEFAULT_PDF_RENDER_LIMITS };
+  const unknownKey = Object.keys(options).find((key) => !(key in result));
+  if (unknownKey) throw new TypeError(`pdf.limits.${unknownKey} is not supported.`);
+  for (const key of Object.keys(result)) {
+    const value = options[key];
+    if (value !== void 0) result[key] = validatePositiveSafeInteger(value, key);
+  }
+  return result;
+};

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

@@ -0,0 +1,6 @@
+import type { PdfDisposition, PdfRenderDiagnostics, PdfRenderResult, ResolvedPdfMetadata } from '../shared/template.js';
+export declare const sanitizePdfFilename: (value: string) => string;
+export declare const createContentDisposition: (disposition: PdfDisposition, filename: string) => string;
+type CompletedRenderDiagnostics = Omit<PdfRenderDiagnostics, 'byteLength'>;
+export declare const createPdfRenderResult: (source: Uint8Array, metadata: ResolvedPdfMetadata, diagnostics: CompletedRenderDiagnostics) => PdfRenderResult;
+export {};

package/dist/runtime/server/result.js

@@ -0,0 +1,81 @@
+import { Buffer } from "node:buffer";
+const DEFAULT_BASENAME = "document";
+const DEFAULT_FILENAME = `${DEFAULT_BASENAME}.pdf`;
+const PDF_EXTENSION = ".pdf";
+const MAX_FILENAME_CODE_POINTS = 180;
+const MAX_ENCODED_FILENAME_LENGTH = 600;
+const MAX_ASCII_FILENAME_LENGTH = 180;
+const UNSAFE_FILENAME_CHARACTERS = /[\p{Cc}"\\/:*?<>|\u061C\u200E\u200F\u202A-\u202E\u2066-\u2069]/gu;
+const EDGE_DOTS_OR_SPACES = /^[.\s]+|[.\s]+$/g;
+const encodeFilename = (filename) => encodeURIComponent(filename).replace(
+  /[!'()*]/g,
+  (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`
+);
+const truncateFilenameBase = (base) => {
+  const maxBaseCodePoints = MAX_FILENAME_CODE_POINTS - PDF_EXTENSION.length;
+  let encodedLength = encodeFilename(PDF_EXTENSION).length;
+  let points = 0;
+  let result = "";
+  for (const character of base) {
+    const characterLength = encodeFilename(character).length;
+    if (points >= maxBaseCodePoints || encodedLength + characterLength > MAX_ENCODED_FILENAME_LENGTH) break;
+    result += character;
+    encodedLength += characterLength;
+    points += 1;
+  }
+  return result.replace(EDGE_DOTS_OR_SPACES, "") || DEFAULT_BASENAME;
+};
+export const sanitizePdfFilename = (value) => {
+  const normalized = value.toWellFormed().normalize("NFKC").replace(UNSAFE_FILENAME_CHARACTERS, "_").replace(/\s+/g, " ").replace(EDGE_DOTS_OR_SPACES, "");
+  const base = normalized.toLowerCase().endsWith(PDF_EXTENSION) ? normalized.slice(0, -PDF_EXTENSION.length) : normalized;
+  return `${truncateFilenameBase(base)}${PDF_EXTENSION}`;
+};
+const asciiFilename = (filename) => {
+  const base = filename.slice(0, -PDF_EXTENSION.length).normalize("NFKD").replace(/[^\x20-\x7E]/g, "_").replace(/["\\]/g, "_").replace(EDGE_DOTS_OR_SPACES, "").slice(0, MAX_ASCII_FILENAME_LENGTH - PDF_EXTENSION.length).replace(EDGE_DOTS_OR_SPACES, "");
+  return `${base || DEFAULT_BASENAME}${PDF_EXTENSION}`;
+};
+export const createContentDisposition = (disposition, filename) => {
+  const safeFilename = sanitizePdfFilename(filename);
+  return `${disposition}; filename="${asciiFilename(safeFilename)}"; filename*=UTF-8''${encodeFilename(safeFilename)}`;
+};
+export const createPdfRenderResult = (source, metadata, diagnostics) => {
+  const bytes = new Uint8Array(source);
+  const completedDiagnostics = Object.freeze({
+    byteLength: bytes.byteLength,
+    durationMs: diagnostics.durationMs,
+    pageCount: diagnostics.pageCount,
+    passes: diagnostics.passes,
+    registeredFontFaces: Object.freeze(diagnostics.registeredFontFaces.map((face) => Object.freeze({ ...face })))
+  });
+  const completedMetadata = Object.freeze({
+    filename: metadata.filename,
+    language: metadata.language,
+    title: metadata.title
+  });
+  return Object.freeze({
+    metadata: completedMetadata,
+    diagnostics: completedDiagnostics,
+    async toUint8Array() {
+      return new Uint8Array(bytes);
+    },
+    async toBuffer() {
+      return Buffer.from(bytes);
+    },
+    async response(init = {}) {
+      const {
+        disposition = "attachment",
+        filename = completedMetadata.filename ?? DEFAULT_FILENAME,
+        headers: initialHeaders,
+        ...responseInit
+      } = init;
+      const headers = new Headers(initialHeaders);
+      headers.set("content-type", "application/pdf");
+      headers.set("content-length", String(bytes.byteLength));
+      headers.set(
+        "content-disposition",
+        createContentDisposition(disposition, filename)
+      );
+      return new Response(new Uint8Array(bytes), { ...responseInit, headers });
+    }
+  });
+};

package/dist/runtime/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../.nuxt/tsconfig.server.json",
+}

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

@@ -0,0 +1,22 @@
+export declare const PDF_ERROR_CODES: {
+    readonly AssetBlocked: "PDF_ASSET_BLOCKED";
+    readonly AssetInvalid: "PDF_ASSET_INVALID";
+    readonly LayoutError: "PDF_LAYOUT_ERROR";
+    readonly LimitExceeded: "PDF_LIMIT_EXCEEDED";
+    readonly TreeInvalid: "PDF_TREE_INVALID";
+    readonly TemplateNotFound: "PDF_TEMPLATE_NOT_FOUND";
+    readonly TemplateInvalid: "PDF_TEMPLATE_INVALID";
+    readonly RenderError: "PDF_RENDER_ERROR";
+};
+export type PdfErrorCode = (typeof PDF_ERROR_CODES)[keyof typeof PDF_ERROR_CODES];
+export interface NuxtPdfErrorOptions {
+    cause?: unknown;
+    templateKey?: string;
+    templateFile?: string;
+}
+export declare class NuxtPdfError extends Error {
+    readonly code: PdfErrorCode;
+    readonly templateKey?: string;
+    readonly templateFile?: string;
+    constructor(code: PdfErrorCode, message: string, options?: NuxtPdfErrorOptions);
+}

package/dist/runtime/shared/errors.js

@@ -0,0 +1,22 @@
+export const PDF_ERROR_CODES = {
+  AssetBlocked: "PDF_ASSET_BLOCKED",
+  AssetInvalid: "PDF_ASSET_INVALID",
+  LayoutError: "PDF_LAYOUT_ERROR",
+  LimitExceeded: "PDF_LIMIT_EXCEEDED",
+  TreeInvalid: "PDF_TREE_INVALID",
+  TemplateNotFound: "PDF_TEMPLATE_NOT_FOUND",
+  TemplateInvalid: "PDF_TEMPLATE_INVALID",
+  RenderError: "PDF_RENDER_ERROR"
+};
+export class NuxtPdfError extends Error {
+  code;
+  templateKey;
+  templateFile;
+  constructor(code, message, options = {}) {
+    super(message, { cause: options.cause });
+    this.name = "NuxtPdfError";
+    this.code = code;
+    this.templateKey = options.templateKey;
+    this.templateFile = options.templateFile;
+  }
+}

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

@@ -0,0 +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';

package/dist/runtime/shared/index.js

@@ -0,0 +1,7 @@
+export {
+  NuxtPdfError,
+  PDF_ERROR_CODES
+} from "./errors.js";
+export {
+  PDF_DEFINITION_PROPERTY
+} from "./template.js";

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

@@ -0,0 +1,63 @@
+import type { AllowedComponentProps, Component, ComponentCustomProps, FunctionalComponent, VNodeProps } from 'vue';
+export declare const PDF_DEFINITION_PROPERTY: "__nuxtPdf";
+export type PdfMetadataValue<Props extends object> = string | ((props: Readonly<Props>) => string);
+export interface PdfDefinition<Props extends object = Record<string, unknown>> {
+    title?: PdfMetadataValue<Props>;
+    filename?: PdfMetadataValue<Props>;
+    language?: string;
+    /**
+     * Maximum number of layout passes the multi-pass (table-of-contents) loop runs
+     * before it declares the page numbers non-convergent and throws
+     * `PDF_LIMIT_EXCEEDED`. A positive integer; defaults to 5. Only relevant to
+     * documents that read `usePdfPageNumbers()` — internal `#id` links alone
+     * resolve in a single pass and never enter the loop.
+     */
+    maxPasses?: number;
+    sampleData?: Props;
+    scenarios?: Readonly<Record<string, Props>>;
+}
+export interface ResolvedPdfMetadata {
+    readonly title?: string;
+    readonly filename?: string;
+    readonly language?: string;
+}
+export type PdfComponent<Props extends object = Record<string, unknown>> = Component & {
+    readonly [PDF_DEFINITION_PROPERTY]?: PdfDefinition<Props>;
+};
+type VueFrameworkProps = VNodeProps & AllowedComponentProps & ComponentCustomProps;
+/** Props authored by a component, excluding Vue's renderer-level vnode props. */
+export type PdfComponentProps<C extends Component> = C extends abstract new (...args: never[]) => {
+    $props: infer Props extends object;
+} ? Omit<Props, keyof VueFrameworkProps> : C extends FunctionalComponent<infer Props extends object> ? Props : Record<string, unknown>;
+export type PdfDisposition = 'attachment' | 'inline';
+export interface PdfResponseInit extends Omit<ResponseInit, 'headers'> {
+    disposition?: PdfDisposition;
+    filename?: string;
+    headers?: HeadersInit;
+}
+/** Safe, content-free measurements from one completed PDF render. */
+export interface PdfRenderDiagnostics {
+    readonly durationMs: number;
+    readonly byteLength: number;
+    readonly pageCount: number;
+    readonly passes: number;
+    readonly registeredFontFaces: readonly PdfRegisteredFontFace[];
+}
+export interface PdfRegisteredFontFace {
+    readonly family: string;
+    readonly fontStyle?: string;
+    readonly fontWeight?: number;
+}
+export interface PdfRenderResult {
+    readonly metadata: Readonly<ResolvedPdfMetadata>;
+    readonly diagnostics: PdfRenderDiagnostics;
+    toUint8Array(): Promise<Uint8Array>;
+    toBuffer(): Promise<Buffer>;
+    response(init?: PdfResponseInit): Promise<Response>;
+}
+export interface PdfTemplate<Props extends object = Record<string, unknown>> {
+    readonly key: string;
+    resolveMetadata(props: Props): ResolvedPdfMetadata;
+    render(props: Props): Promise<PdfRenderResult>;
+}
+export {};

package/dist/runtime/shared/template.js

@@ -0,0 +1 @@
+export const PDF_DEFINITION_PROPERTY = "__nuxtPdf";