@lupinum/nuxt-pdf 0.3.0

package/dist/runtime/authoring.d.ts

@@ -0,0 +1,141 @@
+import type { PdfFontStyle, PdfFontWeight } from './fonts.js';
+/** Stable host tags shared by PDF authoring components and the renderer. */
+export declare const PDF_PRIMITIVES: {
+    readonly Document: "DOCUMENT";
+    readonly Page: "PAGE";
+    readonly View: "VIEW";
+    readonly Text: "TEXT";
+    readonly Image: "IMAGE";
+    readonly Link: "LINK";
+    readonly Note: "NOTE";
+    readonly Tspan: "TSPAN";
+    readonly Svg: "SVG";
+    readonly G: "G";
+    readonly Path: "PATH";
+    readonly Rect: "RECT";
+    readonly Circle: "CIRCLE";
+    readonly Ellipse: "ELLIPSE";
+    readonly Line: "LINE";
+    readonly Polyline: "POLYLINE";
+    readonly Polygon: "POLYGON";
+    readonly Defs: "DEFS";
+    readonly ClipPath: "CLIP_PATH";
+    readonly LinearGradient: "LINEAR_GRADIENT";
+    readonly RadialGradient: "RADIAL_GRADIENT";
+    readonly Stop: "STOP";
+    readonly TextInstance: "TEXT_INSTANCE";
+};
+/** Units resolved by the PDF stylesheet engine. Unitless numbers are points. */
+export type PdfLengthUnit = 'pt' | 'px' | 'in' | 'mm' | 'cm' | 'rem' | 'vh' | 'vw';
+export type PdfUnitLength = `${number}${PdfLengthUnit}`;
+export type PdfPercentage = `${number}%`;
+export type PdfLength = number | PdfUnitLength;
+export type PdfLengthOrPercentage = PdfLength | PdfPercentage;
+export type PdfBorderStyle = 'solid' | 'dashed' | 'dotted';
+export type PdfFlexDirection = 'row' | 'row-reverse' | 'column' | 'column-reverse';
+export type PdfFlexWrap = 'nowrap' | 'wrap' | 'wrap-reverse';
+export type PdfAlignItems = 'flex-start' | 'flex-end' | 'center' | 'stretch' | 'baseline';
+export type PdfJustifyContent = 'flex-start' | 'flex-end' | 'center' | 'space-between' | 'space-around' | 'space-evenly';
+export type PdfTextAlign = 'left' | 'right' | 'center' | 'justify';
+export type PdfTextDecoration = 'none' | 'underline' | 'line-through' | 'underline line-through' | 'line-through underline';
+export type PdfTextTransform = 'none' | 'capitalize' | 'lowercase' | 'uppercase';
+export type PdfObjectFit = 'contain' | 'cover';
+/**
+ * Transform operations covered by the conformance corpus. Translation values
+ * are unitless points because the pinned transform parser does not resolve CSS
+ * length units inside `translate()`.
+ */
+export type PdfTransformOperation = `rotate(${number}deg)` | `rotate(${number}rad)` | `scale(${number})` | `scale(${number},${number})` | `scale(${number}, ${number})` | `scale(${number} ${number})` | `translate(${number},${number})` | `translate(${number}, ${number})` | `translate(${number} ${number})`;
+/** One to three left-to-right transform operations. */
+export type PdfTransform = PdfTransformOperation | `${PdfTransformOperation} ${PdfTransformOperation}` | `${PdfTransformOperation} ${PdfTransformOperation} ${PdfTransformOperation}`;
+/**
+ * Framework-owned style surface for PDF primitives.
+ *
+ * This deliberately describes the tested Nuxt PDF contract instead of
+ * re-exporting the wider, version-dependent upstream stylesheet types.
+ */
+export interface PdfStyle {
+    width?: PdfLengthOrPercentage;
+    height?: PdfLengthOrPercentage;
+    minWidth?: PdfLengthOrPercentage;
+    minHeight?: PdfLengthOrPercentage;
+    maxWidth?: PdfLengthOrPercentage;
+    maxHeight?: PdfLengthOrPercentage;
+    flex?: number;
+    flexBasis?: PdfLengthOrPercentage | 'auto';
+    flexDirection?: PdfFlexDirection;
+    flexGrow?: number;
+    flexShrink?: number;
+    flexWrap?: PdfFlexWrap;
+    alignItems?: PdfAlignItems;
+    justifyContent?: PdfJustifyContent;
+    gap?: PdfLength;
+    margin?: PdfLengthOrPercentage | 'auto';
+    marginHorizontal?: PdfLengthOrPercentage | 'auto';
+    marginVertical?: PdfLengthOrPercentage | 'auto';
+    marginTop?: PdfLengthOrPercentage | 'auto';
+    marginRight?: PdfLengthOrPercentage | 'auto';
+    marginBottom?: PdfLengthOrPercentage | 'auto';
+    marginLeft?: PdfLengthOrPercentage | 'auto';
+    padding?: PdfLengthOrPercentage;
+    paddingHorizontal?: PdfLengthOrPercentage;
+    paddingVertical?: PdfLengthOrPercentage;
+    paddingTop?: PdfLengthOrPercentage;
+    paddingRight?: PdfLengthOrPercentage;
+    paddingBottom?: PdfLengthOrPercentage;
+    paddingLeft?: PdfLengthOrPercentage;
+    position?: 'absolute' | 'relative';
+    top?: PdfLengthOrPercentage;
+    right?: PdfLengthOrPercentage;
+    bottom?: PdfLengthOrPercentage;
+    left?: PdfLengthOrPercentage;
+    backgroundColor?: string;
+    color?: string;
+    opacity?: number;
+    borderWidth?: PdfLength;
+    borderColor?: string;
+    borderStyle?: PdfBorderStyle;
+    borderRadius?: PdfLength;
+    borderTopWidth?: PdfLength;
+    borderTopColor?: string;
+    borderTopStyle?: PdfBorderStyle;
+    borderRightWidth?: PdfLength;
+    borderRightColor?: string;
+    borderRightStyle?: PdfBorderStyle;
+    borderBottomWidth?: PdfLength;
+    borderBottomColor?: string;
+    borderBottomStyle?: PdfBorderStyle;
+    borderLeftWidth?: PdfLength;
+    borderLeftColor?: string;
+    borderLeftStyle?: PdfBorderStyle;
+    borderTopLeftRadius?: PdfLengthOrPercentage;
+    borderTopRightRadius?: PdfLengthOrPercentage;
+    borderBottomRightRadius?: PdfLengthOrPercentage;
+    borderBottomLeftRadius?: PdfLengthOrPercentage;
+    fontFamily?: string;
+    fontSize?: PdfLength;
+    fontStyle?: PdfFontStyle;
+    fontWeight?: PdfFontWeight;
+    letterSpacing?: PdfLength;
+    lineHeight?: number | PdfUnitLength | PdfPercentage;
+    maxLines?: number;
+    textAlign?: PdfTextAlign;
+    textDecoration?: PdfTextDecoration;
+    textDecorationColor?: string;
+    textDecorationStyle?: PdfBorderStyle;
+    textOverflow?: 'ellipsis';
+    textTransform?: PdfTextTransform;
+    objectFit?: PdfObjectFit;
+    transform?: PdfTransform;
+}
+/** One recursively nestable entry inside a style array. */
+export type PdfStyleEntry = PdfStyle | readonly PdfStyleEntry[] | false | null | undefined;
+/** A style object or a recursively nested, left-to-right style array. */
+export type PdfStyleValue = PdfStyle | readonly PdfStyleEntry[];
+export type PdfDynamicPageProps = {
+    pageNumber: number;
+    totalPages?: number;
+    subPageNumber?: number;
+    subPageTotalPages?: number;
+};
+export type PdfDynamicTextRender = (props: PdfDynamicPageProps) => string | number | null | undefined;

package/dist/runtime/authoring.js

@@ -0,0 +1,25 @@
+export const PDF_PRIMITIVES = {
+  Document: "DOCUMENT",
+  Page: "PAGE",
+  View: "VIEW",
+  Text: "TEXT",
+  Image: "IMAGE",
+  Link: "LINK",
+  Note: "NOTE",
+  Tspan: "TSPAN",
+  Svg: "SVG",
+  G: "G",
+  Path: "PATH",
+  Rect: "RECT",
+  Circle: "CIRCLE",
+  Ellipse: "ELLIPSE",
+  Line: "LINE",
+  Polyline: "POLYLINE",
+  Polygon: "POLYGON",
+  Defs: "DEFS",
+  ClipPath: "CLIP_PATH",
+  LinearGradient: "LINEAR_GRADIENT",
+  RadialGradient: "RADIAL_GRADIENT",
+  Stop: "STOP",
+  TextInstance: "TEXT_INSTANCE"
+};

package/dist/runtime/components/_props.d.ts

@@ -0,0 +1,196 @@
+import type { PdfDynamicTextRender, PdfStyleValue } from '../authoring.js';
+export type PdfBookmark = string | {
+    title: string;
+    expanded?: boolean;
+};
+export type PdfBaseProps = {
+    id?: string;
+    fixed?: boolean;
+    break?: boolean;
+    debug?: boolean;
+    minPresenceAhead?: number;
+    style?: PdfStyleValue;
+};
+type PdfBookmarkProp = {
+    bookmark?: PdfBookmark;
+};
+export type PdfDocumentProps = {
+    title?: string;
+    author?: string;
+    subject?: string;
+    creator?: string;
+    keywords?: string;
+    producer?: string;
+    language?: string;
+    creationDate?: Date;
+    pdfVersion?: '1.3' | '1.4' | '1.5' | '1.6' | '1.7' | '1.7ext3';
+    pageLayout?: 'singlePage' | 'oneColumn' | 'twoColumnLeft' | 'twoColumnRight' | 'twoPageLeft' | 'twoPageRight';
+};
+export declare const PDF_PAGE_SIZE_NAMES: readonly ["4A0", "2A0", "A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7", "A8", "A9", "A10", "B0", "B1", "B2", "B3", "B4", "B5", "B6", "B7", "B8", "B9", "B10", "C0", "C1", "C2", "C3", "C4", "C5", "C6", "C7", "C8", "C9", "C10", "RA0", "RA1", "RA2", "RA3", "RA4", "SRA0", "SRA1", "SRA2", "SRA3", "SRA4", "EXECUTIVE", "FOLIO", "LEGAL", "LETTER", "TABLOID", "ID1"];
+export type PdfPageSizeName = (typeof PDF_PAGE_SIZE_NAMES)[number];
+export type PdfPageUnit = 'pt' | 'in' | 'mm' | 'cm' | 'px';
+export type PdfPageDimension = number | `${number}${PdfPageUnit}`;
+export type PdfPageSize = PdfPageSizeName | readonly [PdfPageDimension, PdfPageDimension] | {
+    width: PdfPageDimension;
+    height: PdfPageDimension;
+};
+export type PdfPageProps = PdfBaseProps & PdfBookmarkProp & {
+    wrap?: boolean;
+    size?: PdfPageSize;
+    orientation?: 'portrait' | 'landscape';
+    dpi?: number;
+};
+/** Numeric SVG values accepted by the pinned layout parser. */
+export type PdfSvgNumber = number | `${number}`;
+export type PdfSvgLength = PdfSvgNumber | `${number}%`;
+export type PdfSvgTransformOperation = `translate(${number})` | `translate(${number},${number})` | `translate(${number}, ${number})` | `translate(${number} ${number})` | `rotate(${number})`;
+export type PdfSvgTransform = PdfSvgTransformOperation | `${PdfSvgTransformOperation} ${PdfSvgTransformOperation}` | `${PdfSvgTransformOperation} ${PdfSvgTransformOperation} ${PdfSvgTransformOperation}`;
+export type PdfViewProps = PdfBaseProps & PdfBookmarkProp & {
+    wrap?: boolean;
+};
+type PdfFlowTextProps = PdfBaseProps & PdfBookmarkProp & {
+    wrap?: boolean;
+    widows?: number;
+    orphans?: number;
+    render?: PdfDynamicTextRender;
+    hyphenationCallback?: (word: string) => string[];
+};
+type PdfSvgTextProps = {
+    /** SVG text positioning is explicit and required inside a `PdfSvg`. */
+    x: PdfSvgLength;
+    y: PdfSvgLength;
+    fill?: string;
+    style?: PdfStyleValue;
+    hyphenationCallback?: (word: string) => string[];
+};
+export type PdfTextProps = PdfFlowTextProps | PdfSvgTextProps;
+export type PdfImageSource = string | Uint8Array | ArrayBuffer | {
+    data: Uint8Array;
+    format: 'png' | 'jpg';
+} | {
+    uri: string;
+    format?: 'png' | 'jpg';
+};
+type PdfImageSourceProp = {
+    src: PdfImageSource;
+    source?: never;
+} | {
+    src?: never;
+    source: PdfImageSource;
+};
+export type PdfImageProps = PdfBaseProps & PdfBookmarkProp & PdfImageSourceProp;
+type PdfLinkTarget = {
+    href: string;
+    src?: never;
+} | {
+    href?: never;
+    src: string;
+};
+export type PdfLinkProps = PdfBaseProps & PdfLinkTarget & {
+    wrap?: boolean;
+    hitSlop?: {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+    };
+};
+export type PdfNoteProps = PdfBaseProps;
+/**
+ * Fixture-proven subset of the engine's SVG presentation attributes. On SVG
+ * nodes these are camelCase props. `transform` is a prop here (unlike
+ * `PdfView`, where it is a style key).
+ */
+export type PdfSvgPresentationProps = {
+    fill?: string;
+    stroke?: string;
+    transform?: PdfSvgTransform;
+    strokeWidth?: PdfSvgNumber;
+    fillOpacity?: PdfSvgLength;
+    strokeOpacity?: PdfSvgLength;
+    strokeLinecap?: 'butt' | 'round' | 'square';
+    strokeLinejoin?: 'miter' | 'round' | 'bevel';
+    clipPath?: string;
+};
+export type PdfSvgProps = {
+    width?: PdfSvgLength;
+    height?: PdfSvgLength;
+    viewBox?: string;
+    /** Page-flow sizing and positioning for the SVG root. */
+    style?: PdfStyleValue;
+};
+export type PdfGProps = PdfSvgPresentationProps;
+export type PdfPathProps = PdfSvgPresentationProps & {
+    d: string;
+};
+export type PdfRectProps = PdfSvgPresentationProps & {
+    x?: PdfSvgLength;
+    y?: PdfSvgLength;
+    width: PdfSvgLength;
+    height: PdfSvgLength;
+    rx?: PdfSvgLength;
+    ry?: PdfSvgLength;
+};
+export type PdfCircleProps = PdfSvgPresentationProps & {
+    cx?: PdfSvgLength;
+    cy?: PdfSvgLength;
+    r: PdfSvgLength;
+};
+export type PdfEllipseProps = PdfSvgPresentationProps & {
+    cx?: PdfSvgLength;
+    cy?: PdfSvgLength;
+    rx: PdfSvgLength;
+    ry: PdfSvgLength;
+};
+export type PdfLineProps = PdfSvgPresentationProps & {
+    x1: PdfSvgLength;
+    y1: PdfSvgLength;
+    x2: PdfSvgLength;
+    y2: PdfSvgLength;
+};
+export type PdfPolylineProps = PdfSvgPresentationProps & {
+    points: string;
+};
+export type PdfPolygonProps = PdfSvgPresentationProps & {
+    points: string;
+};
+export type PdfDefsProps = Record<never, never>;
+export type PdfClipPathProps = {
+    id: string;
+};
+type PdfGradientProps = {
+    id: string;
+};
+export type PdfLinearGradientProps = PdfGradientProps & {
+    x1?: PdfSvgLength;
+    y1?: PdfSvgLength;
+    x2?: PdfSvgLength;
+    y2?: PdfSvgLength;
+};
+export type PdfRadialGradientProps = PdfGradientProps & {
+    cx?: PdfSvgLength;
+    cy?: PdfSvgLength;
+    r?: PdfSvgLength;
+    fx?: PdfSvgLength;
+    fy?: PdfSvgLength;
+};
+export type PdfStopProps = {
+    offset: PdfSvgLength;
+    stopColor: string;
+    stopOpacity?: PdfSvgLength;
+};
+export type PdfTspanProps = {
+    x?: PdfSvgLength;
+    y?: PdfSvgLength;
+    fill?: string;
+};
+/**
+ * Compact props for PDF and SVG primitives, coercing kebab-case attribute
+ * names (`stroke-width`, `stop-color`, `min-presence-ahead`) to the exact
+ * camelCase keys the engine reads. Without this, static kebab attributes from
+ * Vue templates would silently no-op. Pure input coercion, not a second
+ * source of truth. `data-`/`aria-` names stay kebab so `patchPdfProp` keeps
+ * rejecting them as DOM-only.
+ */
+export declare const compactProps: (props: object) => Record<string, unknown>;
+export {};

package/dist/runtime/components/_props.js

@@ -0,0 +1,63 @@
+export const PDF_PAGE_SIZE_NAMES = [
+  "4A0",
+  "2A0",
+  "A0",
+  "A1",
+  "A2",
+  "A3",
+  "A4",
+  "A5",
+  "A6",
+  "A7",
+  "A8",
+  "A9",
+  "A10",
+  "B0",
+  "B1",
+  "B2",
+  "B3",
+  "B4",
+  "B5",
+  "B6",
+  "B7",
+  "B8",
+  "B9",
+  "B10",
+  "C0",
+  "C1",
+  "C2",
+  "C3",
+  "C4",
+  "C5",
+  "C6",
+  "C7",
+  "C8",
+  "C9",
+  "C10",
+  "RA0",
+  "RA1",
+  "RA2",
+  "RA3",
+  "RA4",
+  "SRA0",
+  "SRA1",
+  "SRA2",
+  "SRA3",
+  "SRA4",
+  "EXECUTIVE",
+  "FOLIO",
+  "LEGAL",
+  "LETTER",
+  "TABLOID",
+  "ID1"
+];
+const KEBAB_SEGMENT = /-([a-z])/g;
+const normalizePropName = (key) => key.startsWith("data-") || key.startsWith("aria-") ? key : key.replace(KEBAB_SEGMENT, (_, letter) => letter.toUpperCase());
+export const compactProps = (props) => {
+  const result = {};
+  for (const [key, value] of Object.entries(props)) {
+    if (value === void 0) continue;
+    result[normalizePropName(key)] = value;
+  }
+  return result;
+};

package/dist/runtime/components/document.d.ts

@@ -0,0 +1,9 @@
+import { type FunctionalComponent } from 'vue';
+import { type PdfDocumentProps, type PdfImageProps, type PdfLinkProps, type PdfNoteProps, type PdfPageProps, type PdfTextProps, type PdfViewProps } from './_props.js';
+export declare const PdfDocument: FunctionalComponent<PdfDocumentProps>;
+export declare const PdfPage: FunctionalComponent<PdfPageProps>;
+export declare const PdfView: FunctionalComponent<PdfViewProps>;
+export declare const PdfText: FunctionalComponent<PdfTextProps>;
+export declare const PdfImage: FunctionalComponent<PdfImageProps>;
+export declare const PdfLink: FunctionalComponent<PdfLinkProps>;
+export declare const PdfNote: FunctionalComponent<PdfNoteProps>;

package/dist/runtime/components/document.js

@@ -0,0 +1,26 @@
+import { h } from "vue";
+import { PDF_PRIMITIVES } from "../authoring.js";
+import {
+  compactProps
+} from "./_props.js";
+export const PdfDocument = (props, { slots }) => h(PDF_PRIMITIVES.Document, compactProps(props), slots.default?.());
+PdfDocument.displayName = "PdfDocument";
+PdfDocument.inheritAttrs = false;
+export const PdfPage = (props, { slots }) => h(PDF_PRIMITIVES.Page, compactProps(props), slots.default?.());
+PdfPage.displayName = "PdfPage";
+PdfPage.inheritAttrs = false;
+export const PdfView = (props, { slots }) => h(PDF_PRIMITIVES.View, compactProps(props), slots.default?.());
+PdfView.displayName = "PdfView";
+PdfView.inheritAttrs = false;
+export const PdfText = (props, { slots }) => h(PDF_PRIMITIVES.Text, compactProps(props), slots.default?.());
+PdfText.displayName = "PdfText";
+PdfText.inheritAttrs = false;
+export const PdfImage = (props) => h(PDF_PRIMITIVES.Image, compactProps(props));
+PdfImage.displayName = "PdfImage";
+PdfImage.inheritAttrs = false;
+export const PdfLink = (props, { slots }) => h(PDF_PRIMITIVES.Link, compactProps(props), slots.default?.());
+PdfLink.displayName = "PdfLink";
+PdfLink.inheritAttrs = false;
+export const PdfNote = (props, { slots }) => h(PDF_PRIMITIVES.Note, compactProps(props), slots.default?.());
+PdfNote.displayName = "PdfNote";
+PdfNote.inheritAttrs = false;

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

@@ -0,0 +1,4 @@
+export { PdfDocument, PdfImage, PdfLink, PdfNote, PdfPage, PdfText, PdfView, } from './document.js';
+export { PDF_PAGE_SIZE_NAMES } from './_props.js';
+export { PdfCircle, PdfClipPath, PdfDefs, PdfEllipse, PdfG, PdfLine, PdfLinearGradient, PdfPath, PdfPolygon, PdfPolyline, PdfRadialGradient, PdfRect, PdfStop, PdfSvg, PdfTspan, } from './svg.js';
+export type { PdfBaseProps, PdfBookmark, PdfCircleProps, PdfClipPathProps, PdfDefsProps, PdfDocumentProps, PdfEllipseProps, PdfGProps, PdfImageProps, PdfImageSource, PdfLinearGradientProps, PdfLineProps, PdfLinkProps, PdfNoteProps, PdfPageDimension, PdfPageProps, PdfPageSize, PdfPageSizeName, PdfPageUnit, PdfPathProps, PdfPolygonProps, PdfPolylineProps, PdfRadialGradientProps, PdfRectProps, PdfStopProps, PdfSvgPresentationProps, PdfSvgLength, PdfSvgNumber, PdfSvgTransform, PdfSvgTransformOperation, PdfSvgProps, PdfTextProps, PdfTspanProps, PdfViewProps, } from './_props.js';

package/dist/runtime/components/index.js

@@ -0,0 +1,27 @@
+export {
+  PdfDocument,
+  PdfImage,
+  PdfLink,
+  PdfNote,
+  PdfPage,
+  PdfText,
+  PdfView
+} from "./document.js";
+export { PDF_PAGE_SIZE_NAMES } from "./_props.js";
+export {
+  PdfCircle,
+  PdfClipPath,
+  PdfDefs,
+  PdfEllipse,
+  PdfG,
+  PdfLine,
+  PdfLinearGradient,
+  PdfPath,
+  PdfPolygon,
+  PdfPolyline,
+  PdfRadialGradient,
+  PdfRect,
+  PdfStop,
+  PdfSvg,
+  PdfTspan
+} from "./svg.js";

package/dist/runtime/components/svg.d.ts

@@ -0,0 +1,17 @@
+import { type FunctionalComponent } from 'vue';
+import { type PdfCircleProps, type PdfClipPathProps, type PdfDefsProps, type PdfEllipseProps, type PdfGProps, type PdfLinearGradientProps, type PdfLineProps, type PdfPathProps, type PdfPolygonProps, type PdfPolylineProps, type PdfRadialGradientProps, type PdfRectProps, type PdfStopProps, type PdfSvgProps, type PdfTspanProps } from './_props.js';
+export declare const PdfSvg: FunctionalComponent<PdfSvgProps>;
+export declare const PdfG: FunctionalComponent<PdfGProps>;
+export declare const PdfPath: FunctionalComponent<PdfPathProps>;
+export declare const PdfRect: FunctionalComponent<PdfRectProps>;
+export declare const PdfCircle: FunctionalComponent<PdfCircleProps>;
+export declare const PdfEllipse: FunctionalComponent<PdfEllipseProps>;
+export declare const PdfLine: FunctionalComponent<PdfLineProps>;
+export declare const PdfPolyline: FunctionalComponent<PdfPolylineProps>;
+export declare const PdfPolygon: FunctionalComponent<PdfPolygonProps>;
+export declare const PdfDefs: FunctionalComponent<PdfDefsProps>;
+export declare const PdfClipPath: FunctionalComponent<PdfClipPathProps>;
+export declare const PdfLinearGradient: FunctionalComponent<PdfLinearGradientProps>;
+export declare const PdfRadialGradient: FunctionalComponent<PdfRadialGradientProps>;
+export declare const PdfStop: FunctionalComponent<PdfStopProps>;
+export declare const PdfTspan: FunctionalComponent<PdfTspanProps>;

package/dist/runtime/components/svg.js

@@ -0,0 +1,50 @@
+import { h } from "vue";
+import { PDF_PRIMITIVES } from "../authoring.js";
+import {
+  compactProps
+} from "./_props.js";
+export const PdfSvg = (props, { slots }) => h(PDF_PRIMITIVES.Svg, compactProps(props), slots.default?.());
+PdfSvg.displayName = "PdfSvg";
+PdfSvg.inheritAttrs = false;
+export const PdfG = (props, { slots }) => h(PDF_PRIMITIVES.G, compactProps(props), slots.default?.());
+PdfG.displayName = "PdfG";
+PdfG.inheritAttrs = false;
+export const PdfPath = (props) => h(PDF_PRIMITIVES.Path, compactProps(props));
+PdfPath.displayName = "PdfPath";
+PdfPath.inheritAttrs = false;
+export const PdfRect = (props) => h(PDF_PRIMITIVES.Rect, compactProps(props));
+PdfRect.displayName = "PdfRect";
+PdfRect.inheritAttrs = false;
+export const PdfCircle = (props) => h(PDF_PRIMITIVES.Circle, compactProps(props));
+PdfCircle.displayName = "PdfCircle";
+PdfCircle.inheritAttrs = false;
+export const PdfEllipse = (props) => h(PDF_PRIMITIVES.Ellipse, compactProps(props));
+PdfEllipse.displayName = "PdfEllipse";
+PdfEllipse.inheritAttrs = false;
+export const PdfLine = (props) => h(PDF_PRIMITIVES.Line, compactProps(props));
+PdfLine.displayName = "PdfLine";
+PdfLine.inheritAttrs = false;
+export const PdfPolyline = (props) => h(PDF_PRIMITIVES.Polyline, compactProps(props));
+PdfPolyline.displayName = "PdfPolyline";
+PdfPolyline.inheritAttrs = false;
+export const PdfPolygon = (props) => h(PDF_PRIMITIVES.Polygon, compactProps(props));
+PdfPolygon.displayName = "PdfPolygon";
+PdfPolygon.inheritAttrs = false;
+export const PdfDefs = (props, { slots }) => h(PDF_PRIMITIVES.Defs, compactProps(props), slots.default?.());
+PdfDefs.displayName = "PdfDefs";
+PdfDefs.inheritAttrs = false;
+export const PdfClipPath = (props, { slots }) => h(PDF_PRIMITIVES.ClipPath, compactProps(props), slots.default?.());
+PdfClipPath.displayName = "PdfClipPath";
+PdfClipPath.inheritAttrs = false;
+export const PdfLinearGradient = (props, { slots }) => h(PDF_PRIMITIVES.LinearGradient, compactProps(props), slots.default?.());
+PdfLinearGradient.displayName = "PdfLinearGradient";
+PdfLinearGradient.inheritAttrs = false;
+export const PdfRadialGradient = (props, { slots }) => h(PDF_PRIMITIVES.RadialGradient, compactProps(props), slots.default?.());
+PdfRadialGradient.displayName = "PdfRadialGradient";
+PdfRadialGradient.inheritAttrs = false;
+export const PdfStop = (props) => h(PDF_PRIMITIVES.Stop, compactProps(props));
+PdfStop.displayName = "PdfStop";
+PdfStop.inheritAttrs = false;
+export const PdfTspan = (props, { slots }) => h(PDF_PRIMITIVES.Tspan, compactProps(props), slots.default?.());
+PdfTspan.displayName = "PdfTspan";
+PdfTspan.inheritAttrs = false;

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

@@ -0,0 +1,2 @@
+export { usePdfPageNumbers, } from './use-pdf-page-numbers.js';
+export type { PdfPageNumbers, } from './use-pdf-page-numbers.js';

package/dist/runtime/composables/index.js

@@ -0,0 +1,3 @@
+export {
+  usePdfPageNumbers
+} from "./use-pdf-page-numbers.js";

package/dist/runtime/composables/use-pdf-page-numbers.d.ts

@@ -0,0 +1,39 @@
+import { type InjectionKey } from 'vue';
+/**
+ * A readonly, reactive map from a destination `id` to the 1-based page number it
+ * finally resolves to. A value is `undefined` until the layout loop has located
+ * the destination — on the FIRST layout pass every entry is `undefined`, so a
+ * table-of-contents template must tolerate a missing number (render a blank or a
+ * placeholder) rather than assume it exists.
+ */
+export type PdfPageNumbers = Readonly<Record<string, number | undefined>>;
+/**
+ * The value `mountPdfComponent` provides so `usePdfPageNumbers` can read the live
+ * page-number map and flag the render as multi-pass. Injecting it is the ONLY
+ * signal that turns on the fixed-point layout loop; a document that never calls
+ * the composable stays on the single-pass path (internal `#id` links resolve by
+ * name in a single pass and do not need the loop).
+ */
+export interface PdfPageNumbersContext {
+    /** The reactive backing map the render loop feeds each pass. */
+    readonly pages: Record<string, number | undefined>;
+    /** Called at setup time to flag the mounted render as multi-pass. */
+    markUsed(): void;
+}
+export declare const PDF_PAGE_NUMBERS_KEY: InjectionKey<PdfPageNumbersContext>;
+/**
+ * Access the resolved page number of every destination `id` in the current PDF.
+ * Auto-imported inside PDF templates and components. Calling it flags the render
+ * as multi-pass: the engine lays the document out repeatedly, feeding each pass's
+ * `id → page` map back through this composable until the numbers stabilize.
+ *
+ * ```ts
+ * const pageNumbers = usePdfPageNumbers()
+ * // in the template: {{ pageNumbers[section.id] ?? '' }}
+ * ```
+ *
+ * Outside a PDF render there is nothing to resolve, and a silently empty map
+ * would be indistinguishable from legitimate first-pass state, so calling it
+ * anywhere but a PDF template's setup fails fast instead.
+ */
+export declare const usePdfPageNumbers: () => PdfPageNumbers;

package/dist/runtime/composables/use-pdf-page-numbers.js

@@ -0,0 +1,17 @@
+import {
+  inject,
+  readonly
+} from "vue";
+import { NuxtPdfError, PDF_ERROR_CODES } from "../shared/errors.js";
+export const PDF_PAGE_NUMBERS_KEY = Symbol.for("@lupinum/nuxt-pdf:page-numbers");
+export const usePdfPageNumbers = () => {
+  const context = inject(PDF_PAGE_NUMBERS_KEY, null);
+  if (!context) {
+    throw new NuxtPdfError(
+      PDF_ERROR_CODES.TemplateInvalid,
+      "usePdfPageNumbers() is only available inside a PDF template rendered by nuxt-pdf. Call it in the setup of a pdfs/*.vue template or a component it renders."
+    );
+  }
+  context.markUsed();
+  return readonly(context.pages);
+};

package/dist/runtime/define-pdf.d.ts

@@ -0,0 +1,6 @@
+import type { PdfDefinition } from './shared/template.js';
+/**
+ * Type and runtime fallback for the `definePdf` compiler macro.
+ * Discovered PDF templates erase this call before execution.
+ */
+export declare function definePdf<Props extends object = Record<string, unknown>>(_definition: PdfDefinition<Props>): void;

package/dist/runtime/define-pdf.js

@@ -0,0 +1,5 @@
+export function definePdf(_definition) {
+  throw new Error(
+    "definePdf() is a compiler macro that only works as a top-level call in a discovered pdfs/*.vue template."
+  );
+}

package/dist/runtime/fonts.d.ts

@@ -0,0 +1,16 @@
+export type PdfFontStyle = 'italic' | 'normal' | 'oblique';
+export type PdfFontWeightName = 'black' | 'bold' | 'demibold' | 'extrabold' | 'extralight' | 'hairline' | 'heavy' | 'light' | 'medium' | 'normal' | 'semibold' | 'thin' | 'ultrabold' | 'ultralight';
+export type PdfFontWeight = number | PdfFontWeightName;
+export interface PdfFontDeclaration {
+    family: string;
+    src: string;
+    fontStyle?: PdfFontStyle;
+    fontWeight?: PdfFontWeight;
+}
+export type PdfFontDataUrl = `data:font/${'otf' | 'ttf'};base64,${string}`;
+export interface BundledPdfFontDescriptor {
+    family: string;
+    src: PdfFontDataUrl;
+    fontStyle?: PdfFontStyle;
+    fontWeight?: number;
+}