@formepdf/renderer 0.7.0

package/dist/bundle.d.ts

@@ -0,0 +1,2 @@
+export declare const BUNDLE_DIR: string;
+export declare function bundleFile(filePath: string): Promise<string>;

package/dist/bundle.js

@@ -0,0 +1,86 @@
+import { build } from 'esbuild';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+/// The temp directory for bundled output — placed inside renderer package
+/// so that Node's module resolution finds @formepdf/react, @formepdf/core, react.
+export const BUNDLE_DIR = join(__dirname, '..');
+/// esbuild plugin that intercepts react/jsx-dev-runtime to capture source
+/// locations in a global WeakMap. React 19 no longer stores _source on
+/// elements, so we wrap jsxDEV to do it ourselves.
+const formeJsxSourcePlugin = {
+    name: 'forme-jsx-source',
+    setup(pluginBuild) {
+        pluginBuild.onResolve({ filter: /^react\/jsx-dev-runtime$/ }, () => ({
+            path: 'forme-jsx-dev-runtime',
+            namespace: 'forme-jsx',
+        }));
+        pluginBuild.onLoad({ filter: /.*/, namespace: 'forme-jsx' }, () => {
+            const cwd = pluginBuild.initialOptions.absWorkingDir || process.cwd();
+            return {
+                contents: `
+          import { jsx, Fragment } from 'react/jsx-runtime';
+          import { resolve, isAbsolute } from 'node:path';
+          export { Fragment };
+          if (!globalThis.__formeSourceMap) globalThis.__formeSourceMap = new WeakMap();
+          const _cwd = ${JSON.stringify(cwd)};
+          export function jsxDEV(type, props, key, isStaticChildren, source, self) {
+            const el = jsx(type, props, key);
+            if (source && source.fileName) {
+              try {
+                const file = isAbsolute(source.fileName) ? source.fileName : resolve(_cwd, source.fileName);
+                globalThis.__formeSourceMap.set(el, { file, line: source.lineNumber, column: source.columnNumber });
+              } catch(e) {}
+            }
+            return el;
+          }
+        `,
+                resolveDir: cwd,
+                loader: 'js',
+            };
+        });
+    },
+};
+/// Bundle a TSX/JSX file into an ESM string that can be dynamically imported.
+export async function bundleFile(filePath) {
+    try {
+        const result = await build({
+            entryPoints: [filePath],
+            bundle: true,
+            format: 'esm',
+            platform: 'node',
+            write: false,
+            jsx: 'automatic',
+            jsxDev: true,
+            target: 'node20',
+            external: ['react', '@formepdf/react', '@formepdf/core'],
+            plugins: [formeJsxSourcePlugin],
+        });
+        return result.outputFiles[0].text;
+    }
+    catch (err) {
+        if (isBuildFailure(err)) {
+            const messages = [];
+            for (const error of err.errors) {
+                let loc = '';
+                if (error.location) {
+                    const { file, line, column, lineText } = error.location;
+                    loc = `  ${file}:${line}:${column}\n`;
+                    if (lineText) {
+                        loc += `  ${lineText}\n`;
+                        loc += `  ${' '.repeat(column)}^\n`;
+                    }
+                }
+                messages.push(`${error.text}\n${loc}`);
+            }
+            throw new Error(`Build error:\n${messages.join('\n')}`);
+        }
+        throw err;
+    }
+}
+function isBuildFailure(err) {
+    return (err !== null &&
+        typeof err === 'object' &&
+        'errors' in err &&
+        Array.isArray(err.errors));
+}

package/dist/element.d.ts

@@ -0,0 +1,6 @@
+import { type ReactElement } from 'react';
+export interface ResolveElementOptions {
+    dataPath?: string;
+    data?: unknown;
+}
+export declare function resolveElement(mod: Record<string, unknown>, options?: ResolveElementOptions): Promise<ReactElement>;

package/dist/element.js

@@ -0,0 +1,59 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { isValidElement } from 'react';
+/// Validate a module's default export and resolve it to a React element.
+/// Supports both static JSX exports and functions that accept data.
+/// When `data` is provided, it takes precedence over `dataPath`.
+export async function resolveElement(mod, options) {
+    const exported = mod.default;
+    if (exported === undefined) {
+        throw new Error(`No default export found.\n\n` +
+            `  Your file must export a Forme element or a function that returns one:\n\n` +
+            `    export default (\n` +
+            `      <Document>\n` +
+            `        <Text>Hello</Text>\n` +
+            `      </Document>\n` +
+            `    );\n\n` +
+            `  Or with data:\n\n` +
+            `    export default function Report(data) {\n` +
+            `      return <Document><Text>{data.title}</Text></Document>\n` +
+            `    }`);
+    }
+    if (typeof exported === 'function') {
+        let data = {};
+        if (options?.data !== undefined) {
+            data = options.data;
+        }
+        else if (options?.dataPath) {
+            data = await loadJsonData(options.dataPath);
+        }
+        const result = await exported(data);
+        if (!isValidElement(result)) {
+            throw new Error(`Default export function did not return a valid Forme element.\n` +
+                `  Got: ${typeof result}\n` +
+                `  Make sure your function returns a <Document> element.`);
+        }
+        return result;
+    }
+    if (isValidElement(exported)) {
+        if (options?.dataPath) {
+            console.warn(`Warning: --data flag provided but default export is a static element, not a function.\n` +
+                `  The data file will be ignored. Export a function to use --data.`);
+        }
+        return exported;
+    }
+    throw new Error(`Default export is not a valid Forme element.\n` +
+        `  Got: ${typeof exported}\n` +
+        `  Expected: a <Document> element or a function that returns one.`);
+}
+async function loadJsonData(dataPath) {
+    const absolutePath = resolve(dataPath);
+    const raw = await readFile(absolutePath, 'utf-8');
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`Failed to parse data file as JSON: ${absolutePath}\n` +
+            `  Make sure the file contains valid JSON.`);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { renderFromFile, renderFromCode, renderFromElement, type RenderOptions, type RenderResult, } from './render.js';
+export { resolveElement, type ResolveElementOptions, } from './element.js';
+export { bundleFile, } from './bundle.js';
+export { resolveFontSources, resolveImageSources, resolveAllSources, uint8ArrayToBase64, } from './resolve.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+export { renderFromFile, renderFromCode, renderFromElement, } from './render.js';
+export { resolveElement, } from './element.js';
+export { bundleFile, } from './bundle.js';
+export { resolveFontSources, resolveImageSources, resolveAllSources, uint8ArrayToBase64, } from './resolve.js';