@lupinum/nuxt-pdf 0.3.0

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

@@ -0,0 +1,3 @@
+export { mountPdfComponent } from './render-component.js';
+export type { MountedPdfComponent, PdfComponentProps, } from './render-component.js';
+export type { PdfDocumentNode, PdfElementNode, PdfNode, PdfRoot, PdfTextInstance, } from './types.js';

package/dist/runtime/renderer/index.js

@@ -0,0 +1 @@
+export { mountPdfComponent } from "./render-component.js";

package/dist/runtime/renderer/node-ops.d.ts

@@ -0,0 +1,5 @@
+import type { RendererOptions } from 'vue';
+import { type PdfHostElement, type PdfHostNode, type PdfRoot } from './types.js';
+export declare const createPdfRoot: () => PdfRoot;
+export type PdfHostErrorHandler = (error: unknown) => void;
+export declare const createPdfNodeOps: (onError?: PdfHostErrorHandler) => RendererOptions<PdfHostNode, PdfHostElement>;

package/dist/runtime/renderer/node-ops.js

@@ -0,0 +1,281 @@
+import { PDF_PRIMITIVES } from "../authoring.js";
+import { NuxtPdfError, PDF_ERROR_CODES } from "../shared/errors.js";
+import { patchPdfProp } from "./patch-prop.js";
+import {
+  PDF_COMMENT,
+  PDF_PRIMITIVE_NAMES,
+  isPdfCommentNode,
+  isPdfElementNode,
+  isPdfElementType,
+  isPdfTextInstance
+} from "./types.js";
+const TEXT_CONTAINERS = /* @__PURE__ */ new Set([
+  PDF_PRIMITIVES.Text,
+  PDF_PRIMITIVES.Link,
+  PDF_PRIMITIVES.Tspan,
+  PDF_PRIMITIVES.Note
+]);
+const PAGE_CHILDREN = /* @__PURE__ */ new Set([
+  PDF_PRIMITIVES.View,
+  PDF_PRIMITIVES.Text,
+  PDF_PRIMITIVES.Image,
+  PDF_PRIMITIVES.Link,
+  PDF_PRIMITIVES.Note,
+  PDF_PRIMITIVES.Svg
+]);
+const SVG_SHAPES = [
+  PDF_PRIMITIVES.Path,
+  PDF_PRIMITIVES.Rect,
+  PDF_PRIMITIVES.Circle,
+  PDF_PRIMITIVES.Ellipse,
+  PDF_PRIMITIVES.Line,
+  PDF_PRIMITIVES.Polyline,
+  PDF_PRIMITIVES.Polygon
+];
+const G_CHILDREN = /* @__PURE__ */ new Set([
+  ...SVG_SHAPES,
+  PDF_PRIMITIVES.G,
+  PDF_PRIMITIVES.Image,
+  PDF_PRIMITIVES.Text
+]);
+const NO_CHILDREN = /* @__PURE__ */ new Set();
+const ELEMENT_CHILDREN = {
+  [PDF_PRIMITIVES.Document]: /* @__PURE__ */ new Set([PDF_PRIMITIVES.Page]),
+  [PDF_PRIMITIVES.Page]: PAGE_CHILDREN,
+  [PDF_PRIMITIVES.View]: PAGE_CHILDREN,
+  [PDF_PRIMITIVES.Text]: /* @__PURE__ */ new Set([
+    PDF_PRIMITIVES.Text,
+    PDF_PRIMITIVES.Image,
+    PDF_PRIMITIVES.Link,
+    PDF_PRIMITIVES.Tspan
+  ]),
+  [PDF_PRIMITIVES.Image]: NO_CHILDREN,
+  [PDF_PRIMITIVES.Link]: /* @__PURE__ */ new Set([
+    PDF_PRIMITIVES.View,
+    PDF_PRIMITIVES.Image,
+    PDF_PRIMITIVES.Text
+  ]),
+  [PDF_PRIMITIVES.Note]: NO_CHILDREN,
+  [PDF_PRIMITIVES.Tspan]: NO_CHILDREN,
+  [PDF_PRIMITIVES.Svg]: /* @__PURE__ */ new Set([...G_CHILDREN, PDF_PRIMITIVES.Defs]),
+  [PDF_PRIMITIVES.G]: G_CHILDREN,
+  [PDF_PRIMITIVES.Defs]: /* @__PURE__ */ new Set([
+    PDF_PRIMITIVES.ClipPath,
+    PDF_PRIMITIVES.LinearGradient,
+    PDF_PRIMITIVES.RadialGradient
+  ]),
+  [PDF_PRIMITIVES.ClipPath]: new Set(SVG_SHAPES),
+  [PDF_PRIMITIVES.LinearGradient]: /* @__PURE__ */ new Set([PDF_PRIMITIVES.Stop]),
+  [PDF_PRIMITIVES.RadialGradient]: /* @__PURE__ */ new Set([PDF_PRIMITIVES.Stop]),
+  [PDF_PRIMITIVES.Path]: NO_CHILDREN,
+  [PDF_PRIMITIVES.Rect]: NO_CHILDREN,
+  [PDF_PRIMITIVES.Circle]: NO_CHILDREN,
+  [PDF_PRIMITIVES.Ellipse]: NO_CHILDREN,
+  [PDF_PRIMITIVES.Line]: NO_CHILDREN,
+  [PDF_PRIMITIVES.Polyline]: NO_CHILDREN,
+  [PDF_PRIMITIVES.Polygon]: NO_CHILDREN,
+  [PDF_PRIMITIVES.Stop]: NO_CHILDREN
+};
+export const createPdfRoot = () => ({
+  type: "ROOT",
+  document: null
+});
+const throwHostError = (error) => {
+  throw error;
+};
+export const createPdfNodeOps = (onError = throwHostError) => {
+  const childOrder = /* @__PURE__ */ new WeakMap();
+  const parents = /* @__PURE__ */ new WeakMap();
+  const childrenOf = (parent) => {
+    let children = childOrder.get(parent);
+    if (!children) {
+      children = [];
+      childOrder.set(parent, children);
+    }
+    return children;
+  };
+  const rejectOrphanText = (parent) => {
+    const message = parent ? `<${PDF_PRIMITIVE_NAMES[parent.type]}> cannot contain text. Wrap it in <PdfText>.` : "A PDF component root cannot contain text outside <PdfDocument>.";
+    throw new NuxtPdfError(PDF_ERROR_CODES.TreeInvalid, message);
+  };
+  const rejectInvalidChild = (parent, child) => {
+    throw new NuxtPdfError(
+      PDF_ERROR_CODES.TreeInvalid,
+      `Invalid PDF nesting: <${PDF_PRIMITIVE_NAMES[parent.type]}> cannot contain <${PDF_PRIMITIVE_NAMES[child.type]}>.`
+    );
+  };
+  const syncRoot = (root, children) => {
+    const elements = children.filter(isPdfElementNode);
+    for (const child of children) {
+      if (isPdfTextInstance(child) && child.value.trim() !== "") {
+        rejectOrphanText();
+      }
+    }
+    if (elements.length === 0) {
+      root.document = null;
+      return;
+    }
+    if (elements.length !== 1 || elements[0]?.type !== PDF_PRIMITIVES.Document) {
+      throw new NuxtPdfError(
+        PDF_ERROR_CODES.TreeInvalid,
+        "A PDF component must render exactly one PdfDocument at its root."
+      );
+    }
+    root.document = elements[0];
+  };
+  const syncElement = (element, children) => {
+    const acceptsText = TEXT_CONTAINERS.has(element.type);
+    const pdfChildren = [];
+    for (const child of children) {
+      if (isPdfCommentNode(child)) continue;
+      if (isPdfElementNode(child) && !ELEMENT_CHILDREN[element.type].has(child.type)) {
+        rejectInvalidChild(element, child);
+      }
+      if (isPdfTextInstance(child)) {
+        if (!acceptsText) {
+          if (child.value.trim() !== "") rejectOrphanText(element);
+          continue;
+        }
+      }
+      pdfChildren.push(child);
+    }
+    element.children.splice(0, element.children.length, ...pdfChildren);
+  };
+  const sync = (parent) => {
+    const children = childrenOf(parent);
+    if (parent.type === "ROOT") syncRoot(parent, children);
+    else syncElement(parent, children);
+  };
+  const detach = (child) => {
+    const parent = parents.get(child);
+    if (!parent) return;
+    const siblings = childrenOf(parent);
+    const index = siblings.indexOf(child);
+    if (index !== -1) siblings.splice(index, 1);
+    parents.delete(child);
+    sync(parent);
+  };
+  const insert = (child, parent, anchor = null) => {
+    if (child === anchor) return;
+    detach(child);
+    const siblings = childrenOf(parent);
+    const index = anchor == null ? siblings.length : siblings.indexOf(anchor);
+    if (index === -1) {
+      onError(new TypeError("Cannot insert a PDF node before an unknown anchor."));
+      return;
+    }
+    siblings.splice(index, 0, child);
+    parents.set(child, parent);
+    try {
+      sync(parent);
+    } catch (error) {
+      siblings.splice(index, 1);
+      parents.delete(child);
+      sync(parent);
+      onError(error);
+    }
+  };
+  const remove = (child) => {
+    detach(child);
+  };
+  const createElement = (type) => {
+    let elementType;
+    if (!isPdfElementType(type)) {
+      onError(new TypeError(`Unknown PDF primitive "${type}".`));
+      elementType = PDF_PRIMITIVES.View;
+    } else elementType = type;
+    const element = {
+      type: elementType,
+      box: {},
+      style: {},
+      props: {},
+      children: []
+    };
+    childOrder.set(element, []);
+    return element;
+  };
+  const createText = (text) => ({
+    type: PDF_PRIMITIVES.TextInstance,
+    value: text
+  });
+  const createComment = (text) => ({
+    [PDF_COMMENT]: true,
+    value: text
+  });
+  const setText = (node, text) => {
+    if (isPdfElementNode(node)) {
+      onError(new TypeError("Cannot set text directly on a PDF element node."));
+      return;
+    }
+    const previousText = node.value;
+    node.value = text;
+    const parent = parents.get(node);
+    if (!parent) return;
+    try {
+      sync(parent);
+    } catch (error) {
+      node.value = previousText;
+      sync(parent);
+      onError(error);
+    }
+  };
+  const setElementText = (element, text) => {
+    const children = childrenOf(element);
+    const previousChildren = [...children];
+    if (children.length === 1 && isPdfTextInstance(children[0]) && text !== "") {
+      const textNode = children[0];
+      const previousText = textNode.value;
+      textNode.value = text;
+      try {
+        sync(element);
+      } catch (error) {
+        textNode.value = previousText;
+        sync(element);
+        onError(error);
+      }
+      return;
+    }
+    for (const child of children) parents.delete(child);
+    children.length = 0;
+    if (text !== "") {
+      const textNode = createText(text);
+      children.push(textNode);
+      parents.set(textNode, element);
+    }
+    try {
+      sync(element);
+    } catch (error) {
+      for (const child of children) parents.delete(child);
+      children.splice(0, children.length, ...previousChildren);
+      for (const child of previousChildren) parents.set(child, element);
+      sync(element);
+      onError(error);
+    }
+  };
+  const parentNode = (node) => parents.get(node) ?? null;
+  const nextSibling = (node) => {
+    const parent = parents.get(node);
+    if (!parent) return null;
+    const siblings = childrenOf(parent);
+    const index = siblings.indexOf(node);
+    return index === -1 ? null : siblings[index + 1] ?? null;
+  };
+  return {
+    patchProp: (...args) => {
+      try {
+        patchPdfProp(...args);
+      } catch (error) {
+        onError(error);
+      }
+    },
+    insert,
+    remove,
+    createElement,
+    createText,
+    createComment,
+    setText,
+    setElementText,
+    parentNode,
+    nextSibling
+  };
+};

package/dist/runtime/renderer/patch-prop.d.ts

@@ -0,0 +1,3 @@
+import type { RendererOptions } from 'vue';
+import { type PdfHostElement, type PdfHostNode } from './types.js';
+export declare const patchPdfProp: RendererOptions<PdfHostNode, PdfHostElement>['patchProp'];

package/dist/runtime/renderer/patch-prop.js

@@ -0,0 +1,223 @@
+import {
+  PDF_PRIMITIVES
+} from "../authoring.js";
+import { NuxtPdfError, PDF_ERROR_CODES } from "../shared/errors.js";
+import {
+  PDF_PRIMITIVE_NAMES
+} from "./types.js";
+const exactPropNames = () => (names) => new Set(names);
+const BASE_PROP_NAMES = [
+  "break",
+  "debug",
+  "fixed",
+  "id",
+  "minPresenceAhead",
+  "style"
+];
+const BOOKMARK_PROP_NAMES = ["bookmark"];
+const SVG_PRESENTATION_PROP_NAMES = [
+  "clipPath",
+  "fill",
+  "fillOpacity",
+  "stroke",
+  "strokeLinecap",
+  "strokeLinejoin",
+  "strokeOpacity",
+  "strokeWidth",
+  "transform"
+];
+const PDF_PROP_KEYS = {
+  [PDF_PRIMITIVES.Document]: exactPropNames()([
+    "author",
+    "creationDate",
+    "creator",
+    "keywords",
+    "language",
+    "pageLayout",
+    "pdfVersion",
+    "producer",
+    "subject",
+    "title"
+  ]),
+  [PDF_PRIMITIVES.Page]: exactPropNames()([
+    ...BASE_PROP_NAMES,
+    ...BOOKMARK_PROP_NAMES,
+    "dpi",
+    "orientation",
+    "size",
+    "wrap"
+  ]),
+  [PDF_PRIMITIVES.View]: exactPropNames()([
+    ...BASE_PROP_NAMES,
+    ...BOOKMARK_PROP_NAMES,
+    "wrap"
+  ]),
+  [PDF_PRIMITIVES.Text]: exactPropNames()([
+    ...BASE_PROP_NAMES,
+    ...BOOKMARK_PROP_NAMES,
+    "fill",
+    "hyphenationCallback",
+    "orphans",
+    "render",
+    "widows",
+    "wrap",
+    "x",
+    "y"
+  ]),
+  [PDF_PRIMITIVES.Image]: exactPropNames()([
+    ...BASE_PROP_NAMES,
+    ...BOOKMARK_PROP_NAMES,
+    "source",
+    "src"
+  ]),
+  [PDF_PRIMITIVES.Link]: exactPropNames()([
+    ...BASE_PROP_NAMES,
+    "hitSlop",
+    "href",
+    "src",
+    "wrap"
+  ]),
+  [PDF_PRIMITIVES.Note]: exactPropNames()(BASE_PROP_NAMES),
+  [PDF_PRIMITIVES.Tspan]: exactPropNames()(["fill", "x", "y"]),
+  [PDF_PRIMITIVES.Svg]: exactPropNames()([
+    "height",
+    "style",
+    "viewBox",
+    "width"
+  ]),
+  [PDF_PRIMITIVES.G]: exactPropNames()(SVG_PRESENTATION_PROP_NAMES),
+  [PDF_PRIMITIVES.Path]: exactPropNames()([
+    ...SVG_PRESENTATION_PROP_NAMES,
+    "d"
+  ]),
+  [PDF_PRIMITIVES.Rect]: exactPropNames()([
+    ...SVG_PRESENTATION_PROP_NAMES,
+    "height",
+    "rx",
+    "ry",
+    "width",
+    "x",
+    "y"
+  ]),
+  [PDF_PRIMITIVES.Circle]: exactPropNames()([
+    ...SVG_PRESENTATION_PROP_NAMES,
+    "cx",
+    "cy",
+    "r"
+  ]),
+  [PDF_PRIMITIVES.Ellipse]: exactPropNames()([
+    ...SVG_PRESENTATION_PROP_NAMES,
+    "cx",
+    "cy",
+    "rx",
+    "ry"
+  ]),
+  [PDF_PRIMITIVES.Line]: exactPropNames()([
+    ...SVG_PRESENTATION_PROP_NAMES,
+    "x1",
+    "x2",
+    "y1",
+    "y2"
+  ]),
+  [PDF_PRIMITIVES.Polyline]: exactPropNames()([
+    ...SVG_PRESENTATION_PROP_NAMES,
+    "points"
+  ]),
+  [PDF_PRIMITIVES.Polygon]: exactPropNames()([
+    ...SVG_PRESENTATION_PROP_NAMES,
+    "points"
+  ]),
+  [PDF_PRIMITIVES.Defs]: exactPropNames()([]),
+  [PDF_PRIMITIVES.ClipPath]: exactPropNames()(["id"]),
+  [PDF_PRIMITIVES.LinearGradient]: exactPropNames()([
+    "id",
+    "x1",
+    "x2",
+    "y1",
+    "y2"
+  ]),
+  [PDF_PRIMITIVES.RadialGradient]: exactPropNames()([
+    "cx",
+    "cy",
+    "fx",
+    "fy",
+    "id",
+    "r"
+  ]),
+  [PDF_PRIMITIVES.Stop]: exactPropNames()([
+    "offset",
+    "stopColor",
+    "stopOpacity"
+  ])
+};
+const BOOLEAN_PROPS = /* @__PURE__ */ new Set(["break", "debug", "fixed", "wrap"]);
+const EVENT_PROP = /^on[A-Z]/;
+const DOM_ONLY_PROP = /^(?:aria-|data-)/;
+const DOM_ONLY_PROPS = /* @__PURE__ */ new Set([
+  "class",
+  "className",
+  "contenteditable",
+  "contentEditable",
+  "draggable",
+  "hidden",
+  "innerHTML",
+  "role",
+  "slot",
+  "spellcheck",
+  "tabindex",
+  "tabIndex",
+  "textContent",
+  "translate"
+]);
+const treeInvalid = (message) => {
+  throw new NuxtPdfError(PDF_ERROR_CODES.TreeInvalid, message);
+};
+const wrapDynamicText = (render) => (props) => {
+  const result = render(props);
+  if (result == null) return null;
+  if (typeof result !== "string" && typeof result !== "number") {
+    throw new TypeError(
+      "PdfText render callbacks must return a string, number, null, or undefined. Vue VNodes are not supported."
+    );
+  }
+  return String(result);
+};
+export const patchPdfProp = (element, key, _previousValue, nextValue) => {
+  if (element.type === "ROOT") {
+    return treeInvalid(`Cannot set the "${key}" prop on the PDF root.`);
+  }
+  if (EVENT_PROP.test(key)) {
+    treeInvalid(
+      `Vue event prop "${key}" is not supported on PDF primitives.`
+    );
+  }
+  if (DOM_ONLY_PROP.test(key) || DOM_ONLY_PROPS.has(key)) {
+    treeInvalid(
+      `DOM-only attribute "${key}" is not supported on <${PDF_PRIMITIVE_NAMES[element.type]}>. Use PDF props and styles instead.`
+    );
+  }
+  if (!PDF_PROP_KEYS[element.type].has(key)) {
+    treeInvalid(
+      `Unsupported prop "${key}" on <${PDF_PRIMITIVE_NAMES[element.type]}>.`
+    );
+  }
+  if (key === "style") {
+    element.style = nextValue || {};
+    return;
+  }
+  if (nextValue == null) {
+    Reflect.deleteProperty(element.props, key);
+    return;
+  }
+  if (key === "render") {
+    if (element.type !== PDF_PRIMITIVES.Text) {
+      treeInvalid("Dynamic render callbacks are only supported by PdfText.");
+    }
+    if (typeof nextValue !== "function") {
+      treeInvalid("The PdfText render prop must be a function.");
+    }
+    element.props.render = wrapDynamicText(nextValue);
+    return;
+  }
+  element.props[key] = BOOLEAN_PROPS.has(key) && nextValue === "" ? true : nextValue;
+};

package/dist/runtime/renderer/render-component.d.ts

@@ -0,0 +1,14 @@
+import { type Component } from 'vue';
+import type { PdfDocumentNode, PdfRoot } from './types.js';
+export type PdfComponentProps = Record<string, unknown>;
+export type MountedPdfComponent = {
+    readonly document: PdfDocumentNode;
+    readonly root: PdfRoot;
+    /** Whether `usePdfPageNumbers()` was called during mount (flags multi-pass). */
+    readonly usesPageNumbers: boolean;
+    update(props: PdfComponentProps): Promise<PdfDocumentNode>;
+    /** Push a destination `id → page` map into the live tree for the next layout. */
+    feedPageNumbers(pages: Record<string, number>): Promise<PdfDocumentNode>;
+    unmount(): void;
+};
+export declare const mountPdfComponent: (component: Component, initialProps?: PdfComponentProps) => Promise<MountedPdfComponent>;