@ryanyahya/opendoc 0.4.0

package/node_modules/@formepdf/core/pkg-node/forme.js

@@ -0,0 +1,394 @@
+/* @ts-self-types="./forme.d.ts" */
+
+/**
+ * Certify PDF bytes with an X.509 certificate (PKCS#7 detached signature).
+ * @param {Uint8Array} pdf_bytes
+ * @param {string} config_json
+ * @returns {Uint8Array}
+ */
+function certify_pdf(pdf_bytes, config_json) {
+    const ptr0 = passArray8ToWasm0(pdf_bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(config_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.certify_pdf(ptr0, len0, ptr1, len1);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+}
+exports.certify_pdf = certify_pdf;
+
+/**
+ * Find text regions matching patterns in a PDF.
+ * Returns JSON string of Vec<RedactionRegion>.
+ * @param {Uint8Array} pdf_bytes
+ * @param {string} patterns_json
+ * @returns {string}
+ */
+function find_text_regions(pdf_bytes, patterns_json) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passArray8ToWasm0(pdf_bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(patterns_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.find_text_regions(ptr0, len0, ptr1, len1);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
+        if (ret[3]) {
+            ptr3 = 0; len3 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+exports.find_text_regions = find_text_regions;
+
+function init_panic_hook() {
+    wasm.init_panic_hook();
+}
+exports.init_panic_hook = init_panic_hook;
+
+/**
+ * Merge multiple PDFs into a single document.
+ * Accepts a JSON array of base64-encoded PDF strings.
+ * @param {string} pdfs_json
+ * @returns {Uint8Array}
+ */
+function merge_pdfs(pdfs_json) {
+    const ptr0 = passStringToWasm0(pdfs_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.merge_pdfs(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+exports.merge_pdfs = merge_pdfs;
+
+/**
+ * Redact regions of a PDF by overlaying opaque rectangles.
+ * @param {Uint8Array} pdf_bytes
+ * @param {string} redactions_json
+ * @returns {Uint8Array}
+ */
+function redact_pdf(pdf_bytes, redactions_json) {
+    const ptr0 = passArray8ToWasm0(pdf_bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(redactions_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.redact_pdf(ptr0, len0, ptr1, len1);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+}
+exports.redact_pdf = redact_pdf;
+
+/**
+ * Redact text matching patterns from a PDF.
+ * @param {Uint8Array} pdf_bytes
+ * @param {string} patterns_json
+ * @returns {Uint8Array}
+ */
+function redact_text(pdf_bytes, patterns_json) {
+    const ptr0 = passArray8ToWasm0(pdf_bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(patterns_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.redact_text(ptr0, len0, ptr1, len1);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+}
+exports.redact_text = redact_text;
+
+/**
+ * @param {string} json
+ * @returns {Uint8Array}
+ */
+function render_pdf(json) {
+    const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.render_pdf(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+exports.render_pdf = render_pdf;
+
+/**
+ * @param {string} json
+ * @returns {any}
+ */
+function render_pdf_with_layout(json) {
+    const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.render_pdf_with_layout(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.render_pdf_with_layout = render_pdf_with_layout;
+
+/**
+ * @param {string} template_json
+ * @param {string} data_json
+ * @returns {Uint8Array}
+ */
+function render_template_pdf(template_json, data_json) {
+    const ptr0 = passStringToWasm0(template_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(data_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.render_template_pdf(ptr0, len0, ptr1, len1);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+}
+exports.render_template_pdf = render_template_pdf;
+
+/**
+ * @param {string} template_json
+ * @param {string} data_json
+ * @returns {any}
+ */
+function render_template_pdf_with_layout(template_json, data_json) {
+    const ptr0 = passStringToWasm0(template_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(data_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.render_template_pdf_with_layout(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.render_template_pdf_with_layout = render_template_pdf_with_layout;
+
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg_String_8f0eb39a4a4c2f66: function(arg0, arg1) {
+            const ret = String(arg1);
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_throw_be289d5034ed271b: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg_error_7534b8e9a36f1ab4: function(arg0, arg1) {
+            let deferred0_0;
+            let deferred0_1;
+            try {
+                deferred0_0 = arg0;
+                deferred0_1 = arg1;
+                console.error(getStringFromWasm0(arg0, arg1));
+            } finally {
+                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+            }
+        },
+        __wbg_new_361308b2356cecd0: function() {
+            const ret = new Object();
+            return ret;
+        },
+        __wbg_new_3eb36ae241fe6f44: function() {
+            const ret = new Array();
+            return ret;
+        },
+        __wbg_new_8a6f238a6ece86ea: function() {
+            const ret = new Error();
+            return ret;
+        },
+        __wbg_new_from_slice_a3d2629dc1826784: function(arg0, arg1) {
+            const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_now_a3af9a2f4bbaa4d1: function() {
+            const ret = Date.now();
+            return ret;
+        },
+        __wbg_set_3f1d0b984ed272ed: function(arg0, arg1, arg2) {
+            arg0[arg1] = arg2;
+        },
+        __wbg_set_6cb8631f80447a67: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.set(arg0, arg1, arg2);
+            return ret;
+        }, arguments); },
+        __wbg_set_f43e577aea94465b: function(arg0, arg1, arg2) {
+            arg0[arg1 >>> 0] = arg2;
+        },
+        __wbg_stack_0ed75d68575b0f3c: function(arg0, arg1) {
+            const ret = arg1.stack;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbindgen_cast_0000000000000001: function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return ret;
+        },
+        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./forme_bg.js": import0,
+    };
+}
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+function decodeText(ptr, len) {
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const wasmPath = `${__dirname}/forme_bg.wasm`;
+const wasmBytes = require('fs').readFileSync(wasmPath);
+const wasmModule = new WebAssembly.Module(wasmBytes);
+const wasm = new WebAssembly.Instance(wasmModule, __wbg_get_imports()).exports;
+wasm.__wbindgen_start();

package/node_modules/@formepdf/core/pkg-node/forme_bg.wasm.d.ts

@@ -0,0 +1,21 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const certify_pdf: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+export const find_text_regions: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+export const merge_pdfs: (a: number, b: number) => [number, number, number, number];
+export const redact_pdf: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+export const redact_text: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+export const render_pdf: (a: number, b: number) => [number, number, number, number];
+export const render_pdf_with_layout: (a: number, b: number) => [number, number, number];
+export const render_template_pdf: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+export const render_template_pdf_with_layout: (a: number, b: number, c: number, d: number) => [number, number, number];
+export const init_panic_hook: () => void;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_exn_store: (a: number) => void;
+export const __externref_table_alloc: () => number;
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_start: () => void;

package/node_modules/@formepdf/core/pkg-node/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "forme-pdf",
+  "description": "A page-native PDF rendering engine. Layout INTO pages, not onto an infinite canvas.",
+  "version": "0.20.1",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/formepdf/forme"
+  },
+  "files": [
+    "forme_bg.wasm",
+    "forme.js",
+    "forme.d.ts"
+  ],
+  "main": "forme.js",
+  "homepage": "https://formepdf.com",
+  "types": "forme.d.ts",
+  "keywords": [
+    "pdf",
+    "wasm",
+    "layout",
+    "document",
+    "report"
+  ]
+}

package/node_modules/@formepdf/react/README.md

@@ -0,0 +1,70 @@
+# @formepdf/react
+
+React components for [Forme](https://github.com/formepdf/forme) PDF generation.
+
+## Install
+
+```bash
+npm install @formepdf/react @formepdf/core
+```
+
+## Usage
+
+```tsx
+import { Document, Page, View, Text, StyleSheet } from '@formepdf/react';
+import { renderDocument } from '@formepdf/core';
+
+const styles = StyleSheet.create({
+  title: { fontSize: 24, fontWeight: 700, marginBottom: 12 },
+  body: { fontSize: 10, lineHeight: 1.6 },
+});
+
+const doc = (
+  <Document>
+    <Page size="Letter" margin={54}>
+      <Text style={styles.title}>Hello Forme</Text>
+      <Text style={styles.body}>Page breaks that actually work.</Text>
+    </Page>
+  </Document>
+);
+
+const pdfBytes = await renderDocument(doc);
+```
+
+## Components
+
+### Layout
+- `Document` - Root container (fonts, metadata, tagged PDF, PDF/A, signatures)
+- `Page` - A page with size, margins, and orientation
+- `View` - Flex container (like div)
+- `Text` - Text content with font styling
+- `Image` - JPEG, PNG, and WebP images
+- `Fixed` - Fixed headers and footers
+- `PageBreak` - Explicit page break
+
+### Tables
+- `Table`, `Row`, `Cell` - Tables with automatic header repetition across pages
+
+### Graphics
+- `Svg` - SVG rendering via `content` string or JSX children (rect, circle, line, path, arc, opacity)
+- `QrCode` - Vector QR codes
+- `Barcode` - 1D barcodes (Code 128, Code 39, EAN-13, EAN-8, Codabar)
+- `Canvas` - Arbitrary vector drawing via callback API
+- `Watermark` - Rotated text behind page content
+
+### Charts
+- `BarChart` - Vertical bar charts with grouped series
+- `LineChart` - Line charts with multiple series
+- `PieChart` - Pie and donut charts
+- `AreaChart` - Filled area charts
+- `DotPlot` - Dot plot with grouped data points
+
+### Form Fields
+- `TextField` - Text input field
+- `Checkbox` - Checkbox with label
+- `Dropdown` - Select dropdown with options
+- `RadioButton` - Radio button with group support
+
+## Docs
+
+Full documentation at [docs.formepdf.com](https://docs.formepdf.com)

package/node_modules/@formepdf/react/dist/charts.d.ts

@@ -0,0 +1,72 @@
+import React from 'react';
+import type { Style, ChartDataPoint, PieDataPoint } from './types.js';
+interface LegacyBarChartProps {
+    width: number;
+    height: number;
+    data: ChartDataPoint[];
+    color?: string;
+    barGap?: number;
+    showGrid?: boolean;
+    showValues?: boolean;
+    yAxisTicks?: number;
+    style?: Style;
+}
+interface LegacyLineChartProps {
+    width: number;
+    height: number;
+    data: ChartDataPoint[];
+    color?: string;
+    strokeWidth?: number;
+    showDots?: boolean;
+    showGrid?: boolean;
+    showArea?: boolean;
+    style?: Style;
+}
+interface LegacyPieChartProps {
+    width: number;
+    height: number;
+    data: PieDataPoint[];
+    showLabels?: boolean;
+    innerRadius?: number;
+    style?: Style;
+}
+/**
+ * A bar chart rendered as SVG + positioned Text labels.
+ *
+ * @example
+ * ```tsx
+ * <BarChart width={400} height={200}
+ *   data={[{ label: 'Jan', value: 120 }, { label: 'Feb', value: 90 }]}
+ *   color="#1a365d" showGrid showValues />
+ * ```
+ */
+export declare function LegacyBarChart(props: LegacyBarChartProps): React.ReactElement;
+/**
+ * A line chart rendered as SVG + positioned Text labels.
+ *
+ * @example
+ * ```tsx
+ * <LineChart width={400} height={200}
+ *   data={[{ label: 'Jan', value: 120 }, { label: 'Feb', value: 90 }]}
+ *   color="#2b6cb0" showDots showGrid showArea />
+ * ```
+ */
+export declare function LegacyLineChart(props: LegacyLineChartProps): React.ReactElement;
+/**
+ * A pie chart (or donut chart) rendered as SVG + positioned Text labels.
+ *
+ * Requires SVG arc path commands (A/a) — supported since engine v0.6.
+ *
+ * @example
+ * ```tsx
+ * <PieChart width={200} height={200}
+ *   data={[
+ *     { label: 'A', value: 40, color: '#1a365d' },
+ *     { label: 'B', value: 30, color: '#2b6cb0' },
+ *     { label: 'C', value: 30, color: '#63b3ed' },
+ *   ]}
+ *   showLabels />
+ * ```
+ */
+export declare function LegacyPieChart(props: LegacyPieChartProps): React.ReactElement;
+export {};