@polotno/pdf-export 0.1.35 → 0.1.37

package/README.md

@@ -94,6 +94,41 @@ await jsonToPDF(json, './output.pdf', {
 - Spot colors work best with PDF/X-1a export enabled
 - You can verify spot colors in Adobe Acrobat by checking Output Preview > Separations
 
+## DPI Handling
+
+The library automatically handles DPI conversion to ensure correct physical dimensions in the output PDF. By default, it uses the `dpi` value from your JSON file (or 72 DPI if not specified).
+
+```js
+// JSON with dpi specified
+const json = {
+  width: 1920,
+  height: 1080,
+  dpi: 300, // 300 DPI input
+  // ... rest of JSON
+};
+
+// Use JSON dpi automatically
+await jsonToPDF(json, './output.pdf');
+
+// Override DPI via attrs (takes precedence over JSON dpi)
+await jsonToPDF(json, './output.pdf', {
+  dpi: 150, // Override to 150 DPI
+});
+```
+
+**How it works:**
+
+- Input JSON coordinates are in **pixels** at the specified DPI
+- PDF uses **points** (1 point = 1/72 inch)
+- The library converts: `points = pixels × (72 / dpi)`
+- This ensures the PDF has correct physical dimensions for printing
+- All element positions, sizes, and coordinates are automatically scaled
+
+**Example:**
+
+- A 1920×1080 pixel canvas at 300 DPI = 6.4" × 3.6" in the PDF
+- The same canvas at 72 DPI = 26.67" × 15" in the PDF
+
 ## Requirements
 
 - **GhostScript** must be installed for PDF/X-1a conversion

package/lib/index.d.ts

@@ -10,6 +10,7 @@ export interface PolotnoJSON {
         background?: string;
         children: any[];
     }>;
+    dpi?: number;
 }
 export interface RenderAttrs {
     pdfx1a?: boolean;
@@ -22,5 +23,6 @@ export interface RenderAttrs {
     };
     spotColors?: SpotColorConfig;
     textVerticalResizeEnabled?: boolean;
+    dpi?: number;
 }
 export declare function jsonToPDF(json: PolotnoJSON, pdfFileName: string, attrs?: RenderAttrs): Promise<void>;

package/lib/index.js

@@ -4,6 +4,7 @@ import path from 'path';
 import { srcToBuffer, parseColor } from './utils.js';
 import { renderImage } from './image.js';
 import { loadFontIfNeeded, renderText } from './text/index.js';
+import { registerFontUrl } from './text/fonts.js';
 import { renderFigure } from './figure.js';
 import { renderGroup } from './group.js';
 import { lineToPDF } from './line.js';
@@ -51,6 +52,13 @@ async function renderElement({ doc, element, fonts, attrs, cache, }) {
 }
 export async function jsonToPDF(json, pdfFileName, attrs = {}) {
     const fonts = {};
+    // Compute DPI and scale factor
+    // Priority: attrs.dpi (override) > json.dpi > 72 (default)
+    const inputDpi = attrs.dpi ?? json.dpi ?? 72;
+    // Validate DPI: must be finite and positive
+    const validDpi = Number.isFinite(inputDpi) && inputDpi > 0 ? inputDpi : 72;
+    // Convert pixels to PDF points: 1 point = 1/72 inch, so points per pixel = 72 / dpi
+    const ptPerPx = 72 / validDpi;
     // Create cache for images and processed results
     const cache = {
         images: new Map(), // Cache for loaded Canvas images
@@ -60,7 +68,7 @@ export async function jsonToPDF(json, pdfFileName, attrs = {}) {
         tempDir: null, // Temporary directory for image files
     };
     var doc = new PDFDocument({
-        size: [json.width, json.height],
+        size: [json.width * ptPerPx, json.height * ptPerPx],
         autoFirstPage: false,
     });
     // Enable spot color support if configured
@@ -68,11 +76,14 @@ export async function jsonToPDF(json, pdfFileName, attrs = {}) {
         enableSpotColorSupport(doc, attrs.spotColors);
     }
     for (const font of json.fonts) {
-        doc.registerFont(font.fontFamily, await srcToBuffer(font.url, cache));
-        fonts[font.fontFamily] = true;
+        registerFontUrl(font.fontFamily, font.url);
     }
     for (const page of json.pages) {
         doc.addPage();
+        // Apply scale transform so all pixel-based coordinates work correctly
+        // The page size is already in points, but we render in pixel coordinates
+        doc.save();
+        doc.scale(ptPerPx);
         if (page.background) {
             const isURL = page.background.indexOf('http') >= 0 ||
                 page.background.indexOf('.png') >= 0 ||
@@ -91,6 +102,7 @@ export async function jsonToPDF(json, pdfFileName, attrs = {}) {
         for (const element of page.children) {
             await renderElement({ doc, element, fonts, attrs, cache });
         }
+        doc.restore();
     }
     doc.end();
     await new Promise((r) => doc.pipe(fs.createWriteStream(pdfFileName)).on('finish', r));

package/lib/text/fonts.d.ts

@@ -1,4 +1,5 @@
 import { TextElement, TextSegment } from './types.js';
+export declare function registerFontUrl(fontFamily: string, url: string): void;
 /**
  * Get font weight string based on bold/italic state
  */

package/lib/text/fonts.js

@@ -1,6 +1,10 @@
 import { srcToBuffer } from '../utils.js';
 import getUrls from 'get-urls';
 import fetch from 'node-fetch';
+const fontUrlRegistry = {};
+export function registerFontUrl(fontFamily, url) {
+    fontUrlRegistry[fontFamily] = url;
+}
 /**
  * Get font weight string based on bold/italic state
  */
@@ -53,9 +57,20 @@ export async function loadFontForSegment(doc, segment, element, fonts) {
     }
     const fontKey = getFontKey(fontFamily, bold, italic, element.fontWeight);
     if (!fonts[fontKey]) {
-        const weight = getFontWeight(bold, italic, element.fontWeight);
-        const src = await getGoogleFontPath(fontFamily, weight, italic);
-        doc.registerFont(fontKey, await srcToBuffer(src));
+        let src;
+        if (fontUrlRegistry[fontFamily]) {
+            src = fontUrlRegistry[fontFamily];
+        }
+        else {
+            const weight = getFontWeight(bold, italic, element.fontWeight);
+            src = await getGoogleFontPath(fontFamily, weight, italic);
+        }
+        try {
+            doc.registerFont(fontKey, await srcToBuffer(src));
+        }
+        catch (error) {
+            throw new Error(`Failed to load font "${fontFamily}" from ${src}: ${error.message}`);
+        }
         fonts[fontKey] = true;
     }
     doc.font(fontKey);

package/lib/text/render.js

@@ -186,13 +186,14 @@ export async function renderTextFill(doc, element, textLines, yOffset, lineHeigh
         const renderSegments = await buildRenderSegmentsForLine(doc, element, line.text, textOptions, fonts);
         // Apply segment-specific colors for rich text
         const applySegmentColor = (segment) => {
-            const segmentColor = segment.color
-                ? parseColor(segment.color).hex
-                : parseColor(element.fill).hex;
             const segmentParsedColor = segment.color
                 ? parseColor(segment.color)
                 : parseColor(element.fill);
-            const segmentOpacity = Math.min(segmentParsedColor.rgba[3] ?? 1, element.opacity, 1);
+            // Fallback to element fill if segment color parsing fails
+            const segmentColor = segmentParsedColor?.hex || parseColor(element.fill).hex || '#000000';
+            // Segment alpha can be NaN (e.g. rgba(..., var(--x, 1))) -> fallback to 1
+            const a = segmentParsedColor?.rgba?.[3];
+            const segmentOpacity = Math.min(typeof a === 'number' && a >= 0 && a <= 1 ? a : 1, element.opacity, 1);
             doc.fillColor(segmentColor, segmentOpacity);
         };
         await renderSegmentsForLine(doc, element, line, renderSegments, context, textOptions, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polotno/pdf-export",
-  "version": "0.1.35",
+  "version": "0.1.37",
   "description": "Convert Polotno JSON into vector PDF",
   "type": "module",
   "main": "./lib/index.js",