@lupinum/nuxt-pdf 0.3.0

package/dist/runtime/renderer/render-component.js

@@ -0,0 +1,201 @@
+import {
+  createRenderer,
+  createVNode,
+  defineComponent,
+  getCurrentInstance,
+  nextTick,
+  reactive,
+  shallowRef
+} from "vue";
+import { PDF_PAGE_NUMBERS_KEY } from "../composables/use-pdf-page-numbers.js";
+import { PDF_PRIMITIVES } from "../authoring.js";
+import {
+  PdfCircle,
+  PdfClipPath,
+  PdfDefs,
+  PdfDocument,
+  PdfEllipse,
+  PdfG,
+  PdfImage,
+  PdfLine,
+  PdfLinearGradient,
+  PdfLink,
+  PdfNote,
+  PdfPage,
+  PdfPath,
+  PdfPolygon,
+  PdfPolyline,
+  PdfRadialGradient,
+  PdfRect,
+  PdfStop,
+  PdfSvg,
+  PdfText,
+  PdfTspan,
+  PdfView
+} from "../components/index.js";
+import {
+  createPdfNodeOps,
+  createPdfRoot
+} from "./node-ops.js";
+import { NuxtPdfError, PDF_ERROR_CODES } from "../shared/errors.js";
+import { validatePdfDocumentTree } from "./validate-tree.js";
+const PDF_COMPONENTS = {
+  PdfCircle,
+  PdfClipPath,
+  PdfDefs,
+  PdfDocument,
+  PdfEllipse,
+  PdfG,
+  PdfImage,
+  PdfLine,
+  PdfLinearGradient,
+  PdfLink,
+  PdfNote,
+  PdfPage,
+  PdfPath,
+  PdfPolygon,
+  PdfPolyline,
+  PdfRadialGradient,
+  PdfRect,
+  PdfStop,
+  PdfSvg,
+  PdfText,
+  PdfTspan,
+  PdfView
+};
+const ASYNC_AUTHORING_ERROR = "Async setup and async components are not supported in PDF templates. Load request data before render(props) and pass it through typed props.";
+const requireDocument = (root) => {
+  if (root.document?.type !== PDF_PRIMITIVES.Document) {
+    throw new NuxtPdfError(
+      PDF_ERROR_CODES.TreeInvalid,
+      "A PDF component must render exactly one PdfDocument at its root."
+    );
+  }
+  validatePdfDocumentTree(root.document);
+  return root.document;
+};
+export const mountPdfComponent = async (component, initialProps = {}) => {
+  let hasRenderError = false;
+  let renderError;
+  const recordRenderError = (error) => {
+    if (hasRenderError) return;
+    hasRenderError = true;
+    renderError = error;
+  };
+  const resetRenderError = () => {
+    hasRenderError = false;
+    renderError = void 0;
+  };
+  const throwRenderError = () => {
+    if (!hasRenderError) return;
+    const error = renderError;
+    resetRenderError();
+    throw error;
+  };
+  const renderer = createRenderer(
+    createPdfNodeOps(recordRenderError)
+  );
+  const root = createPdfRoot();
+  const currentProps = shallowRef(initialProps);
+  const RootComponent = defineComponent({
+    name: "NuxtPdfRenderRoot",
+    setup: () => () => createVNode(component, currentProps.value)
+  });
+  const app = renderer.createApp(RootComponent);
+  app.mixin({
+    beforeCreate() {
+      const type = getCurrentInstance()?.type;
+      if (typeof type !== "object" || type === null) return;
+      const candidate = type;
+      const setup = candidate.setup;
+      if ("__asyncLoader" in candidate || typeof setup === "function" && setup.constructor.name === "AsyncFunction") {
+        recordRenderError(new NuxtPdfError(
+          PDF_ERROR_CODES.TemplateInvalid,
+          ASYNC_AUTHORING_ERROR
+        ));
+      }
+    }
+  });
+  app.config.errorHandler = recordRenderError;
+  app.config.throwUnhandledErrorInProduction = true;
+  app.config.warnHandler = (message) => recordRenderError(new NuxtPdfError(
+    PDF_ERROR_CODES.TemplateInvalid,
+    message.includes("async setup()") ? ASYNC_AUTHORING_ERROR : `Vue reported an invalid PDF authoring pattern: ${message}`
+  ));
+  for (const [name, primitive] of Object.entries(PDF_COMPONENTS)) {
+    app.component(name, primitive);
+  }
+  const pageNumbers = reactive({});
+  let pageNumbersUsed = false;
+  app.provide(PDF_PAGE_NUMBERS_KEY, {
+    pages: pageNumbers,
+    markUsed: () => {
+      pageNumbersUsed = true;
+    }
+  });
+  let mounted = false;
+  const dispose = (surfaceCleanupError) => {
+    if (!mounted) return;
+    resetRenderError();
+    try {
+      app.unmount();
+      if (surfaceCleanupError) throwRenderError();
+    } finally {
+      mounted = false;
+    }
+  };
+  const fail = (error) => {
+    try {
+      dispose(false);
+    } catch {
+    }
+    throw error;
+  };
+  const requireSuccessfulDocument = () => {
+    throwRenderError();
+    return requireDocument(root);
+  };
+  const updateDocument = async (mutate) => {
+    resetRenderError();
+    try {
+      mutate();
+      await nextTick();
+      return requireSuccessfulDocument();
+    } catch (error) {
+      return fail(error);
+    }
+  };
+  try {
+    app.mount(root);
+    mounted = true;
+    await nextTick();
+    requireSuccessfulDocument();
+  } catch (error) {
+    return fail(error);
+  }
+  return {
+    get document() {
+      return requireDocument(root);
+    },
+    root,
+    get usesPageNumbers() {
+      return pageNumbersUsed;
+    },
+    async update(props) {
+      return updateDocument(() => {
+        currentProps.value = props;
+      });
+    },
+    async feedPageNumbers(pages) {
+      return updateDocument(() => {
+        for (const key of Object.keys(pageNumbers)) {
+          if (!(key in pages)) Reflect.deleteProperty(pageNumbers, key);
+        }
+        Object.assign(pageNumbers, pages);
+      });
+    },
+    unmount() {
+      dispose(true);
+    }
+  };
+};

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

@@ -0,0 +1,33 @@
+import { PDF_PRIMITIVES, type PdfStyleValue } from '../authoring.js';
+export type PdfElementType = Exclude<(typeof PDF_PRIMITIVES)[keyof typeof PDF_PRIMITIVES], typeof PDF_PRIMITIVES.TextInstance>;
+export declare const PDF_PRIMITIVE_NAMES: Record<PdfElementType, string>;
+export type PdfTextInstance = {
+    type: typeof PDF_PRIMITIVES.TextInstance;
+    value: string;
+};
+export type PdfElementNode = {
+    type: PdfElementType;
+    box: Record<string, unknown>;
+    style: PdfStyleValue;
+    props: Record<string, unknown>;
+    children: PdfNode[];
+};
+export type PdfDocumentNode = PdfElementNode & {
+    type: typeof PDF_PRIMITIVES.Document;
+};
+export type PdfNode = PdfElementNode | PdfTextInstance;
+export type PdfRoot = {
+    type: 'ROOT';
+    document: PdfDocumentNode | null;
+};
+export declare const PDF_COMMENT: unique symbol;
+export type PdfCommentNode = {
+    readonly [PDF_COMMENT]: true;
+    value: string;
+};
+export type PdfHostNode = PdfNode | PdfCommentNode;
+export type PdfHostElement = PdfRoot | PdfElementNode;
+export declare const isPdfElementType: (value: string) => value is PdfElementType;
+export declare const isPdfElementNode: (node: PdfHostNode) => node is PdfElementNode;
+export declare const isPdfTextInstance: (node: PdfHostNode) => node is PdfTextInstance;
+export declare const isPdfCommentNode: (node: PdfHostNode) => node is PdfCommentNode;

package/dist/runtime/renderer/types.js

@@ -0,0 +1,56 @@
+import {
+  PDF_PRIMITIVES
+} from "../authoring.js";
+export const PDF_PRIMITIVE_NAMES = {
+  [PDF_PRIMITIVES.Document]: "PdfDocument",
+  [PDF_PRIMITIVES.Page]: "PdfPage",
+  [PDF_PRIMITIVES.View]: "PdfView",
+  [PDF_PRIMITIVES.Text]: "PdfText",
+  [PDF_PRIMITIVES.Image]: "PdfImage",
+  [PDF_PRIMITIVES.Link]: "PdfLink",
+  [PDF_PRIMITIVES.Note]: "PdfNote",
+  [PDF_PRIMITIVES.Tspan]: "PdfTspan",
+  [PDF_PRIMITIVES.Svg]: "PdfSvg",
+  [PDF_PRIMITIVES.G]: "PdfG",
+  [PDF_PRIMITIVES.Path]: "PdfPath",
+  [PDF_PRIMITIVES.Rect]: "PdfRect",
+  [PDF_PRIMITIVES.Circle]: "PdfCircle",
+  [PDF_PRIMITIVES.Ellipse]: "PdfEllipse",
+  [PDF_PRIMITIVES.Line]: "PdfLine",
+  [PDF_PRIMITIVES.Polyline]: "PdfPolyline",
+  [PDF_PRIMITIVES.Polygon]: "PdfPolygon",
+  [PDF_PRIMITIVES.Defs]: "PdfDefs",
+  [PDF_PRIMITIVES.ClipPath]: "PdfClipPath",
+  [PDF_PRIMITIVES.LinearGradient]: "PdfLinearGradient",
+  [PDF_PRIMITIVES.RadialGradient]: "PdfRadialGradient",
+  [PDF_PRIMITIVES.Stop]: "PdfStop"
+};
+export const PDF_COMMENT = Symbol("nuxt-pdf-comment");
+const ELEMENT_TYPES = /* @__PURE__ */ new Set([
+  PDF_PRIMITIVES.Document,
+  PDF_PRIMITIVES.Page,
+  PDF_PRIMITIVES.View,
+  PDF_PRIMITIVES.Text,
+  PDF_PRIMITIVES.Image,
+  PDF_PRIMITIVES.Link,
+  PDF_PRIMITIVES.Note,
+  PDF_PRIMITIVES.Tspan,
+  PDF_PRIMITIVES.Svg,
+  PDF_PRIMITIVES.G,
+  PDF_PRIMITIVES.Path,
+  PDF_PRIMITIVES.Rect,
+  PDF_PRIMITIVES.Circle,
+  PDF_PRIMITIVES.Ellipse,
+  PDF_PRIMITIVES.Line,
+  PDF_PRIMITIVES.Polyline,
+  PDF_PRIMITIVES.Polygon,
+  PDF_PRIMITIVES.Defs,
+  PDF_PRIMITIVES.ClipPath,
+  PDF_PRIMITIVES.LinearGradient,
+  PDF_PRIMITIVES.RadialGradient,
+  PDF_PRIMITIVES.Stop
+]);
+export const isPdfElementType = (value) => ELEMENT_TYPES.has(value);
+export const isPdfElementNode = (node) => "type" in node && node.type !== PDF_PRIMITIVES.TextInstance;
+export const isPdfTextInstance = (node) => "type" in node && node.type === PDF_PRIMITIVES.TextInstance;
+export const isPdfCommentNode = (node) => PDF_COMMENT in node;

package/dist/runtime/renderer/validate-tree.d.ts

@@ -0,0 +1,3 @@
+import { type PdfDocumentNode } from './types.js';
+/** Validate invariants that require the complete mounted document tree. */
+export declare const validatePdfDocumentTree: (document: PdfDocumentNode) => void;