@lupinum/nuxt-pdf 0.3.0

package/dist/runtime/renderer/validate-tree.js

@@ -0,0 +1,428 @@
+import { NuxtPdfError, PDF_ERROR_CODES } from "../shared/errors.js";
+import {
+  PDF_PRIMITIVES
+} from "../authoring.js";
+import { PDF_PAGE_SIZE_NAMES } from "../components/index.js";
+import {
+  PDF_PRIMITIVE_NAMES
+} from "./types.js";
+const RESERVED_DESTINATION_IDS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
+const exactStyleKeys = (keys) => new Set(keys);
+const PDF_STYLE_KEYS = exactStyleKeys([
+  "alignItems",
+  "backgroundColor",
+  "borderBottomColor",
+  "borderBottomLeftRadius",
+  "borderBottomRightRadius",
+  "borderBottomStyle",
+  "borderBottomWidth",
+  "borderColor",
+  "borderLeftColor",
+  "borderLeftStyle",
+  "borderLeftWidth",
+  "borderRadius",
+  "borderRightColor",
+  "borderRightStyle",
+  "borderRightWidth",
+  "borderStyle",
+  "borderTopColor",
+  "borderTopLeftRadius",
+  "borderTopRightRadius",
+  "borderTopStyle",
+  "borderTopWidth",
+  "borderWidth",
+  "bottom",
+  "color",
+  "flex",
+  "flexBasis",
+  "flexDirection",
+  "flexGrow",
+  "flexShrink",
+  "flexWrap",
+  "fontFamily",
+  "fontSize",
+  "fontStyle",
+  "fontWeight",
+  "gap",
+  "height",
+  "justifyContent",
+  "left",
+  "letterSpacing",
+  "lineHeight",
+  "margin",
+  "marginBottom",
+  "marginHorizontal",
+  "marginLeft",
+  "marginRight",
+  "marginTop",
+  "marginVertical",
+  "maxHeight",
+  "maxLines",
+  "maxWidth",
+  "minHeight",
+  "minWidth",
+  "objectFit",
+  "opacity",
+  "padding",
+  "paddingBottom",
+  "paddingHorizontal",
+  "paddingLeft",
+  "paddingRight",
+  "paddingTop",
+  "paddingVertical",
+  "position",
+  "right",
+  "textAlign",
+  "textDecoration",
+  "textDecorationColor",
+  "textDecorationStyle",
+  "textOverflow",
+  "textTransform",
+  "top",
+  "transform",
+  "width"
+]);
+const DESTINATION_TYPES = /* @__PURE__ */ new Set([
+  PDF_PRIMITIVES.Page,
+  PDF_PRIMITIVES.View,
+  PDF_PRIMITIVES.Text,
+  PDF_PRIMITIVES.Image,
+  PDF_PRIMITIVES.Link,
+  PDF_PRIMITIVES.Note
+]);
+const REQUIRED_PROPS = {
+  [PDF_PRIMITIVES.Path]: ["d"],
+  [PDF_PRIMITIVES.Rect]: ["width", "height"],
+  [PDF_PRIMITIVES.Circle]: ["r"],
+  [PDF_PRIMITIVES.Ellipse]: ["rx", "ry"],
+  [PDF_PRIMITIVES.Line]: ["x1", "y1", "x2", "y2"],
+  [PDF_PRIMITIVES.Polyline]: ["points"],
+  [PDF_PRIMITIVES.Polygon]: ["points"],
+  [PDF_PRIMITIVES.ClipPath]: ["id"],
+  [PDF_PRIMITIVES.LinearGradient]: ["id"],
+  [PDF_PRIMITIVES.RadialGradient]: ["id"],
+  [PDF_PRIMITIVES.Stop]: ["offset", "stopColor"]
+};
+const SVG_NUMERIC_PROPS = [
+  "cx",
+  "cy",
+  "fillOpacity",
+  "fx",
+  "fy",
+  "height",
+  "offset",
+  "r",
+  "rx",
+  "ry",
+  "stopOpacity",
+  "strokeOpacity",
+  "strokeWidth",
+  "width",
+  "x",
+  "x1",
+  "x2",
+  "y",
+  "y1",
+  "y2"
+];
+const NON_NEGATIVE_SVG_PROPS = /* @__PURE__ */ new Set([
+  "height",
+  "r",
+  "rx",
+  "ry",
+  "strokeWidth",
+  "width"
+]);
+const UNIT_INTERVAL_SVG_PROPS = /* @__PURE__ */ new Set([
+  "fillOpacity",
+  "offset",
+  "stopOpacity",
+  "strokeOpacity"
+]);
+const FLOW_ONLY_TEXT_PROPS = [
+  "bookmark",
+  "break",
+  "debug",
+  "fixed",
+  "id",
+  "minPresenceAhead",
+  "orphans",
+  "render",
+  "widows",
+  "wrap"
+];
+const SVG_NUMBER = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?(%?)$/i;
+const SVG_TRANSFORM_NUMBER = String.raw`[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?`;
+const SVG_TRANSFORM_OPERATION = String.raw`(?:translate\(${SVG_TRANSFORM_NUMBER}(?:(?:,\s*|\s+)${SVG_TRANSFORM_NUMBER})?\)|rotate\(${SVG_TRANSFORM_NUMBER}\))`;
+const SVG_TRANSFORM = new RegExp(`^${SVG_TRANSFORM_OPERATION}(?:\\s+${SVG_TRANSFORM_OPERATION}){0,2}$`, "i");
+const SVG_DEFINITION_ID = /^[a-z_][\w.:-]*$/i;
+const SVG_REFERENCE = /^url\(['"]?#([^'")]+)['"]?\)$/;
+const PAGE_DIMENSION = /^\+?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?(?:pt|in|mm|cm|px)$/i;
+const PAGE_SIZE_NAMES = new Set(PDF_PAGE_SIZE_NAMES);
+const treeInvalid = (message) => {
+  throw new NuxtPdfError(PDF_ERROR_CODES.TreeInvalid, message);
+};
+const validateDestinationId = (value) => {
+  if (value === void 0) return void 0;
+  if (typeof value === "string") {
+    if (value.trim() === "") {
+      treeInvalid("PDF destination ids must be non-empty strings.");
+    }
+    return value;
+  }
+  return treeInvalid("PDF destination ids must be non-empty strings.");
+};
+const hasProp = (node, key) => Object.hasOwn(node.props, key);
+const validateRequiredProps = (node) => {
+  for (const key of REQUIRED_PROPS[node.type] ?? []) {
+    if (!hasProp(node, key)) {
+      treeInvalid(`<${PDF_PRIMITIVE_NAMES[node.type]}> requires the "${key}" prop.`);
+    }
+  }
+};
+const parseSvgNumber = (value) => {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? { value, percent: false } : void 0;
+  }
+  if (typeof value !== "string") return void 0;
+  const match = SVG_NUMBER.exec(value);
+  if (!match) return void 0;
+  const parsed = Number.parseFloat(value);
+  return Number.isFinite(parsed) ? { value: parsed, percent: match[1] === "%" } : void 0;
+};
+const validateSvgNumbers = (node) => {
+  for (const key of SVG_NUMERIC_PROPS) {
+    if (!hasProp(node, key)) continue;
+    const parsed = parseSvgNumber(node.props[key]);
+    if (!parsed) {
+      return treeInvalid(`<${PDF_PRIMITIVE_NAMES[node.type]}> has an invalid "${key}" value.`);
+    }
+    if (NON_NEGATIVE_SVG_PROPS.has(key) && parsed.value < 0) {
+      treeInvalid(`<${PDF_PRIMITIVE_NAMES[node.type]}> requires a non-negative "${key}" value.`);
+    }
+    if (UNIT_INTERVAL_SVG_PROPS.has(key) && (parsed.value < 0 || parsed.value > (parsed.percent ? 100 : 1))) {
+      treeInvalid(`<${PDF_PRIMITIVE_NAMES[node.type]}> requires "${key}" between 0 and 1 (or 0% and 100%).`);
+    }
+    if (key === "strokeWidth" && parsed.percent) {
+      treeInvalid(`<${PDF_PRIMITIVE_NAMES[node.type]}> does not support a percentage stroke width.`);
+    }
+  }
+};
+const validateViewBox = (node) => {
+  if (node.type !== PDF_PRIMITIVES.Svg || !hasProp(node, "viewBox")) return;
+  const value = node.props.viewBox;
+  const parts = typeof value === "string" ? value.trim().split(/[\s,]+/).map(Number) : [];
+  if (parts.length !== 4 || parts.some((part) => !Number.isFinite(part)) || parts[2] <= 0 || parts[3] <= 0) {
+    treeInvalid("<PdfSvg> viewBox must contain four finite numbers with positive width and height.");
+  }
+};
+const validateSvgTransform = (node) => {
+  if (!hasProp(node, "transform")) return;
+  const value = node.props.transform;
+  if (typeof value !== "string" || !SVG_TRANSFORM.test(value)) {
+    treeInvalid(`<${PDF_PRIMITIVE_NAMES[node.type]}> has an unsupported SVG transform.`);
+  }
+};
+const pageDimensionIsPositive = (value) => {
+  if (typeof value === "number") return Number.isFinite(value) && value > 0;
+  return typeof value === "string" && PAGE_DIMENSION.test(value) && Number.parseFloat(value) > 0;
+};
+const validatePage = (node) => {
+  if (node.type !== PDF_PRIMITIVES.Page) return;
+  if (hasProp(node, "dpi")) {
+    const dpi = node.props.dpi;
+    if (typeof dpi !== "number" || !Number.isFinite(dpi) || dpi <= 0) {
+      treeInvalid("<PdfPage> dpi must be a positive finite number.");
+    }
+  }
+  if (!hasProp(node, "size")) return;
+  const size = node.props.size;
+  let valid = false;
+  if (typeof size === "string") {
+    valid = PAGE_SIZE_NAMES.has(size);
+  } else if (Array.isArray(size)) {
+    valid = size.length === 2 && size.every(pageDimensionIsPositive);
+  } else if (typeof size === "object" && size !== null) {
+    const dimensions = size;
+    valid = pageDimensionIsPositive(dimensions.width) && pageDimensionIsPositive(dimensions.height);
+  }
+  if (!valid) {
+    treeInvalid("<PdfPage> size must be a known page name or positive width and height.");
+  }
+};
+const validateLinkAndImageSources = (node) => {
+  if (node.type === PDF_PRIMITIVES.Image) {
+    if (hasProp(node, "src") === hasProp(node, "source")) {
+      treeInvalid('<PdfImage> requires exactly one of "src" or "source".');
+    }
+  }
+  if (node.type === PDF_PRIMITIVES.Link) {
+    const hasHref = hasProp(node, "href");
+    const hasSrc = hasProp(node, "src");
+    if (hasHref === hasSrc) {
+      treeInvalid('<PdfLink> requires exactly one of "href" or "src".');
+    }
+    const target = hasHref ? node.props.href : node.props.src;
+    if (typeof target !== "string" || target.trim() === "") {
+      treeInvalid("<PdfLink> targets must be non-empty strings.");
+    }
+  }
+};
+const validateScalarInvariants = (node) => {
+  if (hasProp(node, "minPresenceAhead")) {
+    const value = node.props.minPresenceAhead;
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+      treeInvalid(`<${PDF_PRIMITIVE_NAMES[node.type]}> minPresenceAhead must be a non-negative finite number.`);
+    }
+  }
+  for (const key of ["break", "debug", "fixed", "wrap"]) {
+    if (hasProp(node, key) && typeof node.props[key] !== "boolean") {
+      treeInvalid(`<${PDF_PRIMITIVE_NAMES[node.type]}> requires a boolean "${key}" value.`);
+    }
+  }
+};
+const validateStyle = (style) => {
+  if (Array.isArray(style)) {
+    for (const entry of style) {
+      if (entry !== false && entry != null) validateStyle(entry);
+    }
+    return;
+  }
+  if (typeof style !== "object" || style === null) {
+    treeInvalid("PDF styles must be an object or a nested array of style objects.");
+  }
+  for (const key of Object.keys(style)) {
+    if (!PDF_STYLE_KEYS.has(key)) {
+      treeInvalid(`Unsupported PDF style "${key}".`);
+    }
+  }
+};
+const validateTextContext = (node, insideSvg) => {
+  if (node.type === PDF_PRIMITIVES.Tspan && !insideSvg) {
+    treeInvalid("<PdfTspan> is only supported inside SVG text.");
+  }
+  if (node.type !== PDF_PRIMITIVES.Text) return;
+  if (!insideSvg) {
+    if (hasProp(node, "fill") || hasProp(node, "x") || hasProp(node, "y")) {
+      treeInvalid("The PdfText fill, x, and y props are only supported inside <PdfSvg>.");
+    }
+    return;
+  }
+  if (!hasProp(node, "x") || !hasProp(node, "y")) {
+    treeInvalid('SVG <PdfText> requires both "x" and "y" props.');
+  }
+  if (FLOW_ONLY_TEXT_PROPS.some((key) => hasProp(node, key))) {
+    treeInvalid("SVG <PdfText> does not accept page-flow text props.");
+  }
+};
+const validateDefinitionId = (value) => {
+  if (typeof value !== "string" || !SVG_DEFINITION_ID.test(value)) {
+    return treeInvalid("SVG definition ids must be safe non-empty identifiers.");
+  }
+  if (RESERVED_DESTINATION_IDS.has(value)) {
+    treeInvalid("An SVG definition uses a reserved identifier.");
+  }
+  return value;
+};
+const validateSvgDefinitions = (svg) => {
+  const defs = svg.children.filter(
+    (child) => "children" in child && child.type === PDF_PRIMITIVES.Defs
+  );
+  if (defs.length > 1) {
+    treeInvalid("<PdfSvg> accepts at most one <PdfDefs> child.");
+  }
+  const definitions = /* @__PURE__ */ new Map();
+  for (const definition of defs[0]?.children ?? []) {
+    if (!("children" in definition)) continue;
+    const id = validateDefinitionId(definition.props.id);
+    if (definitions.has(id)) treeInvalid("SVG definition ids must be unique within one <PdfSvg>.");
+    definitions.set(id, definition.type);
+  }
+  const pending = [svg];
+  while (pending.length > 0) {
+    const node = pending.pop();
+    if (hasProp(node, "fill") && typeof node.props.fill === "string") {
+      const fill = node.props.fill;
+      if (fill.startsWith("url(")) {
+        const match = SVG_REFERENCE.exec(fill);
+        const type = match ? definitions.get(match[1]) : void 0;
+        if (type !== PDF_PRIMITIVES.LinearGradient && type !== PDF_PRIMITIVES.RadialGradient) {
+          treeInvalid("An SVG fill references a missing or incompatible definition.");
+        }
+      }
+    }
+    if (hasProp(node, "clipPath")) {
+      const clipPath = node.props.clipPath;
+      const match = typeof clipPath === "string" ? SVG_REFERENCE.exec(clipPath) : null;
+      if (!match || definitions.get(match[1]) !== PDF_PRIMITIVES.ClipPath) {
+        treeInvalid("An SVG clipPath references a missing or incompatible definition.");
+      }
+    }
+    for (const child of node.children) {
+      if ("children" in child) pending.push(child);
+    }
+  }
+};
+export const validatePdfDocumentTree = (document) => {
+  const destinationIds = /* @__PURE__ */ new Set();
+  const internalLinkTargets = /* @__PURE__ */ new Set();
+  let pageCount = 0;
+  const pending = [{
+    node: document,
+    insideSvg: false
+  }];
+  while (pending.length > 0) {
+    const { node, insideSvg } = pending.pop();
+    validateRequiredProps(node);
+    validateSvgNumbers(node);
+    validateSvgTransform(node);
+    validateViewBox(node);
+    validatePage(node);
+    validateLinkAndImageSources(node);
+    validateScalarInvariants(node);
+    validateStyle(node.style);
+    validateTextContext(node, insideSvg);
+    if (node.type === PDF_PRIMITIVES.Svg) validateSvgDefinitions(node);
+    if (node.type === PDF_PRIMITIVES.Page) pageCount += 1;
+    if (node.type === PDF_PRIMITIVES.Link) {
+      const target = hasProp(node, "href") ? node.props.href : node.props.src;
+      if (typeof target === "string" && target.startsWith("#")) {
+        const id2 = target.slice(1);
+        if (id2.trim() === "") {
+          treeInvalid("<PdfLink> internal destinations must name a non-empty id.");
+        }
+        internalLinkTargets.add(id2);
+      }
+    }
+    const id = DESTINATION_TYPES.has(node.type) ? validateDestinationId(node.props.id) : void 0;
+    if (id !== void 0) {
+      if (RESERVED_DESTINATION_IDS.has(id)) {
+        treeInvalid("A PDF destination uses a reserved identifier.");
+      }
+      if (destinationIds.has(id)) {
+        treeInvalid("PDF destination ids must be unique within a document.");
+      }
+      destinationIds.add(id);
+    }
+    for (const child of node.children) {
+      if ("children" in child) {
+        pending.push({
+          node: child,
+          insideSvg: insideSvg || node.type === PDF_PRIMITIVES.Svg
+        });
+      }
+    }
+  }
+  if (pageCount === 0) {
+    treeInvalid("<PdfDocument> requires at least one <PdfPage>.");
+  }
+  for (const target of internalLinkTargets) {
+    if (!destinationIds.has(target)) {
+      treeInvalid("<PdfLink> internal destination does not match any id in the document.");
+    }
+  }
+};

package/dist/runtime/server/assets/errors.d.ts

@@ -0,0 +1,12 @@
+import { NuxtPdfError } from '../../shared/errors.js';
+export declare const PDF_ASSET_ERROR_CODES: {
+    readonly Blocked: "PDF_ASSET_BLOCKED";
+    readonly Invalid: "PDF_ASSET_INVALID";
+    readonly LimitExceeded: "PDF_LIMIT_EXCEEDED";
+};
+export type PdfAssetErrorCode = (typeof PDF_ASSET_ERROR_CODES)[keyof typeof PDF_ASSET_ERROR_CODES];
+export declare class PdfAssetError extends NuxtPdfError {
+    constructor(code: PdfAssetErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+}

package/dist/runtime/server/assets/errors.js

@@ -0,0 +1,15 @@
+import {
+  NuxtPdfError,
+  PDF_ERROR_CODES
+} from "../../shared/errors.js";
+export const PDF_ASSET_ERROR_CODES = {
+  Blocked: PDF_ERROR_CODES.AssetBlocked,
+  Invalid: PDF_ERROR_CODES.AssetInvalid,
+  LimitExceeded: PDF_ERROR_CODES.LimitExceeded
+};
+export class PdfAssetError extends NuxtPdfError {
+  constructor(code, message, options = {}) {
+    super(code, message, options);
+    this.name = "PdfAssetError";
+  }
+}

package/dist/runtime/server/assets/remote.d.ts

@@ -0,0 +1,48 @@
+import { Buffer } from 'node:buffer';
+import type { RenderLimits } from '../render-limits.js';
+/** Opt-in policy for runtime image requests. Remote fonts are not supported. */
+export interface RemoteAssetOptions {
+    /** Exact `https://host/path/` prefixes. Wildcard hosts are rejected. */
+    allow: readonly string[];
+    /** Per-hop timeout, bounded by the remaining render deadline. */
+    timeoutMs?: number;
+}
+export interface RemoteAssetRule {
+    readonly host: string;
+    readonly port: string;
+    readonly pathPrefix: string;
+}
+/** JSON-serializable policy generated once during Nuxt module setup. */
+export interface RemoteAssetPolicy {
+    readonly allow: readonly RemoteAssetRule[];
+    readonly timeoutMs: number;
+}
+export declare const DEFAULT_REMOTE_TIMEOUT_MS = 10000;
+export declare const MAX_REMOTE_REDIRECTS = 3;
+/** Runtime URL label safe for logs, preview diagnostics, and attributed errors. */
+export declare const redactUrl: (url: string) => string;
+export declare const normalizeRemoteAssetPolicy: (options: RemoteAssetOptions | undefined) => RemoteAssetPolicy | undefined;
+/** Revalidate scheme, credentials, fragment, host, port, and path on every hop. */
+export declare const matchesAllowlist: (url: string, policy: RemoteAssetPolicy) => boolean;
+type RemoteWaiter = {
+    reject(error: unknown): void;
+    resolve(): void;
+};
+/** Mutable request accounting owned by exactly one render. */
+export interface RemoteRequestState {
+    readonly limits: RenderLimits;
+    active: number;
+    requests: number;
+    readonly waiters: RemoteWaiter[];
+}
+export declare const createRemoteRequestState: (limits: RenderLimits) => RemoteRequestState;
+export interface FetchRemoteResourceOptions {
+    readonly policy: RemoteAssetPolicy;
+    readonly maxBytes: number;
+    readonly state: RemoteRequestState;
+    /** Per-render dedup map so a repeated URL is fetched once. */
+    readonly inflight?: Map<string, Promise<Buffer>>;
+}
+/** Fetch one allowlisted image under the render-wide deadline and budgets. */
+export declare const fetchRemoteResource: (url: string, options: FetchRemoteResourceOptions) => Promise<Buffer>;
+export {};