@formepdf/cli 0.3.0 → 0.4.1

package/dist/index.js

@@ -4,6 +4,7 @@ import { parseArgs } from 'node:util';
 import { resolve } from 'node:path';
 import { startDevServer } from './dev.js';
 import { buildPdf } from './build.js';
+import { buildTemplate } from './template-build.js';
 const USAGE = `
 forme - Page-native PDF rendering engine
 
@@ -12,8 +13,9 @@ Usage:
   forme build <file.tsx>  Render PDF to disk
 
 Options:
-  -o, --output <path>     Output PDF path (build only, default: output.pdf)
+  -o, --output <path>     Output path (default: output.pdf, or <name>.template.json with -t)
   -d, --data <path>       JSON data file to pass to template function
+  -t, --template          Compile to template JSON instead of rendering PDF
   -p, --port <number>     Dev server port (default: 4242)
   -h, --help              Show this help message
 
@@ -37,8 +39,9 @@ function main() {
     const { values, positionals } = parseArgs({
         allowPositionals: true,
         options: {
-            output: { type: 'string', short: 'o', default: 'output.pdf' },
+            output: { type: 'string', short: 'o' },
             data: { type: 'string', short: 'd' },
+            template: { type: 'boolean', short: 't', default: false },
             port: { type: 'string', short: 'p', default: '4242' },
             help: { type: 'boolean', short: 'h', default: false },
         },
@@ -73,7 +76,12 @@ function main() {
             startDevServer(inputPath, { port: Number(values.port), dataPath });
             break;
         case 'build':
-            buildPdf(inputPath, { output: values.output, dataPath });
+            if (values.template) {
+                buildTemplate(inputPath, { output: values.output });
+            }
+            else {
+                buildPdf(inputPath, { output: values.output ?? 'output.pdf', dataPath });
+            }
             break;
         default:
             console.error(`Unknown command: ${command}\n`);

package/dist/template-build.d.ts

@@ -0,0 +1,4 @@
+export interface TemplateBuildOptions {
+    output?: string;
+}
+export declare function buildTemplate(inputPath: string, options: TemplateBuildOptions): Promise<void>;

package/dist/template-build.js

@@ -0,0 +1,81 @@
+import { writeFile } from 'node:fs/promises';
+import { resolve, join, basename } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { isValidElement } from 'react';
+import { bundleFile, BUNDLE_DIR } from './bundle.js';
+export async function buildTemplate(inputPath, options) {
+    const absoluteInput = resolve(inputPath);
+    console.log(`Building template from ${absoluteInput}...`);
+    try {
+        const code = await bundleFile(absoluteInput);
+        const tmpFile = join(BUNDLE_DIR, `.forme-template-${Date.now()}.mjs`);
+        await writeFile(tmpFile, code);
+        try {
+            const mod = await import(pathToFileURL(tmpFile).href);
+            const exported = mod.default;
+            if (exported === undefined) {
+                throw new Error(`No default export found.\n\n` +
+                    `  Your template file must export a function that takes data and returns JSX:\n\n` +
+                    `    export default function Invoice(data) {\n` +
+                    `      return <Document><Text>{data.title}</Text></Document>\n` +
+                    `    }`);
+            }
+            if (typeof exported !== 'function') {
+                throw new Error(`Default export must be a function for template compilation.\n` +
+                    `  Got: ${typeof exported}\n\n` +
+                    `  Export a function that takes data and returns a <Document>:\n\n` +
+                    `    export default function Template(data) {\n` +
+                    `      return <Document>...</Document>\n` +
+                    `    }`);
+            }
+            // Create a recording proxy and call the template function
+            const { createDataProxy, serializeTemplate } = await import('@formepdf/react');
+            const dataProxy = createDataProxy();
+            const element = exported(dataProxy);
+            if (!isValidElement(element)) {
+                throw new Error(`Template function did not return a valid Forme element.\n` +
+                    `  Got: ${typeof element}\n` +
+                    `  Make sure your function returns a <Document> element.`);
+            }
+            const templateJson = serializeTemplate(element);
+            // Resolve fonts to base64 for portability
+            await resolveFontPaths(templateJson, absoluteInput);
+            const outputPath = resolve(options.output ?? defaultTemplateName(inputPath));
+            const json = JSON.stringify(templateJson, null, 2);
+            await writeFile(outputPath, json);
+            console.log(`Written template (${json.length} bytes) to ${outputPath}`);
+        }
+        finally {
+            const { unlink } = await import('node:fs/promises');
+            await unlink(tmpFile).catch(() => { });
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`\n  ${message.split('\n').join('\n  ')}\n`);
+        process.exit(1);
+    }
+}
+function defaultTemplateName(inputPath) {
+    const base = basename(inputPath).replace(/\.(tsx|jsx|ts|js)$/, '');
+    return `${base}.template.json`;
+}
+async function resolveFontPaths(doc, templatePath) {
+    const { dirname } = await import('node:path');
+    const { readFile } = await import('node:fs/promises');
+    const { resolve: resolvePath } = await import('node:path');
+    const templateDir = dirname(templatePath);
+    const fonts = doc.fonts;
+    if (!fonts?.length)
+        return;
+    for (const font of fonts) {
+        if (font.src instanceof Uint8Array) {
+            font.src = Buffer.from(font.src).toString('base64');
+        }
+        else if (typeof font.src === 'string' && !font.src.startsWith('data:')) {
+            const fontPath = resolvePath(templateDir, font.src);
+            const bytes = await readFile(fontPath);
+            font.src = Buffer.from(bytes).toString('base64');
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@formepdf/cli",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "CLI for Forme PDF rendering engine — dev server with live preview and build command",
   "type": "module",
   "bin": {
@@ -14,8 +14,8 @@
     "dist"
   ],
   "dependencies": {
-    "@formepdf/core": "0.3.0",
-    "@formepdf/react": "0.3.0",
+    "@formepdf/core": "0.4.1",
+    "@formepdf/react": "0.4.1",
     "esbuild": "^0.24.0",
     "chokidar": "^4.0.0",
     "ws": "^8.18.0",