@t4h.framework/pdf 0.0.0-experimental-20260907052843

package/.ai/skills/framework-pdf/SKILL.md

@@ -0,0 +1,353 @@
+---
+name: framework-pdf
+description: >-
+  Guides correct use of @t4h.framework/pdf in T4H Framework workflows: the
+  `render()` helper, PDF marker components (Document, Page, View, Text, Link,
+  Image, PageNumber), custom fonts, Binary image sources, styling,
+  password-protected PDFs via the `encrypt` option, and the FileSystemClaim
+  the render activity requires. Use when generating PDFs in workflows,
+  building PDF templates with JSX, registering fonts, encrypting PDFs, or
+  working in packages/pdf.
+---
+
+# @t4h.framework/pdf
+
+Declarative PDF rendering for workflows, backed by `@react-pdf/renderer`.
+Package path: `framework/packages/pdf`. Peer dependencies:
+`@t4h.framework/core`, `@t4h.framework/fs`. Regular dependencies: `react`,
+`@react-pdf/renderer`.
+
+Import surface (from `src/pdf.ts` only — the `helpers/` modules are internal):
+
+```typescript
+import {
+  render,
+  Document,
+  Page,
+  View,
+  Text,
+  Link,
+  Image,
+  PageNumber,
+  RenderPDFActivity,
+  ProtectionFlags,
+  ProtectionPresets,
+  type RenderPDFOptions,
+  type RenderPDFInput,
+  type EncryptPDFOptions,
+  type DocumentProps,
+  type PageProps,
+  type ViewProps,
+  type TextProps,
+  type LinkProps,
+  type ImageProps,
+  type PageNumberProps,
+  type DocumentNode,
+  type PDFNode,
+  type PDFStyle,
+} from '@t4h.framework/pdf'
+```
+
+> Workflows use **`render()`** — for everything, including encryption. The
+> package also exports the underlying `RenderPDFActivity`, but workflow code
+> never imports, instantiates, or extends it. The `encryptPDF` tool in
+> `src/tools/` is internal and not exported — encryption always goes through
+> `render`'s `encrypt` option.
+
+## Architecture
+
+`Workflow` → `render(<Document>…</Document>, options?)`
+(`History.reconciler(RenderPDFActivity)`) →
+
+1. **`toInput`** (workflow side): the JSX tree is serialized into a plain
+   `DocumentNode` JSON tree that is stored in the workflow history. User
+   function components, fragments, arrays, and conditionals are flattened
+   here; only marker components and strings remain.
+2. **`run`** (activity side): fonts are registered, the `DocumentNode` tree is
+   converted back into real `@react-pdf/renderer` elements (`Binary` image
+   sources become `data:` URIs), rendered to a buffer, and written through
+   **`FileSystemClaim`** at `pdf/${activityId}.pdf`. With the `encrypt`
+   option, a password-protected copy is also written at
+   `pdf/${activityId}-encrypted.pdf`.
+3. The activity returns the **`Binary`** the claim produced — a reference to
+   the stored file, not in-memory bytes. Replay-safe by construction. With
+   `encrypt`, it returns the `[original, encrypted]` pair instead, and the
+   `render` return type narrows automatically based on the options.
+
+---
+
+## Claims
+
+### FileSystemClaim (required)
+
+The render activity persists the PDF through `fs`. Any workflow that calls
+`render()` needs a `FileSystemClaim` provider:
+
+```typescript
+{ provide: FileSystemClaim, value: new MyFileSystemClaimImpl() }
+```
+
+Tests mock its `write` to return a `Binary` (see **Testing**).
+
+---
+
+## Marker components
+
+The components exported by this package are **markers**: they exist only as
+type-safe JSX tags inside a tree passed to `render()`. JSX never invokes
+them — the serializer recognizes them by reference. Calling one directly
+(`Image({ src })`) or rendering them with another renderer throws.
+
+| Component | Props (beyond `NodeProps`) | Notes |
+|-----------|---------------------------|-------|
+| `Document` | `title? author? subject? creator? producer? language?` | Root. Children must be `Page` elements |
+| `Page` | `size? orientation? style? wrap? dpi?` | `size` defaults to A4. Overflowing content paginates automatically |
+| `View` | — | Flex container, analogous to a `<div>` |
+| `Text` | — | All raw strings must live inside a `Text` |
+| `Link` | `href` (required) | Hyperlink; serialized `href` becomes react-pdf's `src` internally |
+| `Image` | `src: string \| Binary` (required) | URL, `data:` URI, or `Binary` with an image `contentType` |
+| `PageNumber` | `format?` | Resolves at layout time. Tokens: `{pageNumber}`, `{totalPages}`. Default `'{pageNumber}'`. Combine with `fixed` for running footers |
+
+`NodeProps` (shared by every node inside a page): `style`, `fixed` (repeat on
+every page — headers/footers), `break` (force page break before the node),
+`wrap` (allow splitting across pages, default `true`), `minPresenceAhead`
+(move to next page unless this many points remain — avoids orphaned headings).
+
+**Tree rules enforced at serialization** (violations throw `TypeError`):
+
+- The tree must resolve to a single `Document` root.
+- `Document` children must be `Page` elements.
+- Raw text must be wrapped in `Text` (`"x"` directly inside `View`/`Page` throws).
+- Only `Text`, `Link`, and `PageNumber` are allowed inside `Text`.
+- `Image` is not allowed inside `Text`.
+
+User function components, `.map()` arrays, fragments, and conditional
+rendering (`null` / `false` / `undefined`) work exactly like normal React —
+they are evaluated and flattened during serialization.
+
+---
+
+## Styling
+
+`PDFStyle` is a loose camelCase record (`fontSize`, `flexDirection`,
+`marginTop`, …). Layout is the CSS **flex model only** — no grid, no float.
+Values: numbers are points; strings accept units (`'2cm'`, `'5mm'`, `'50%'`).
+`style` also accepts an array of styles.
+
+Text styles (`color`, `fontSize`, `fontFamily`, …) **inherit** through the
+tree, so defaults belong on `Page`:
+
+```tsx
+<Page size='A4' style={{ padding: '2cm', fontSize: 12, color: '#00513a' }}>
+```
+
+Built-in fonts (no registration needed): Helvetica, Courier, Times-Roman —
+with `fontWeight: 'bold'` / `fontStyle: 'italic'` variants.
+
+---
+
+## Rendering in a workflow
+
+```tsx
+import { Workflow } from '@t4h.framework/core'
+import { Document, Page, PageNumber, Text, View, render } from '@t4h.framework/pdf'
+
+function Header({ title }: { title: string }) {
+  return (
+    <View style={{ borderBottom: '1 solid #333', marginBottom: 16 }}>
+      <Text style={{ fontSize: 18 }}>{title}</Text>
+    </View>
+  )
+}
+
+export const invoice = new Workflow({ id: 'invoice' }, async () => {
+  const pdf = await render(
+    <Document title='Invoice'>
+      <Page size='A4' style={{ padding: '2cm', fontSize: 12 }}>
+        <Header title='Invoice #42' />
+        {items.map(item => (
+          <View key={item.id} style={{ flexDirection: 'row', justifyContent: 'space-between' }}>
+            <Text>{item.label}</Text>
+            <Text>{item.total}</Text>
+          </View>
+        ))}
+        <PageNumber
+          fixed
+          format='{pageNumber}/{totalPages}'
+          style={{ position: 'absolute', bottom: 24, right: '2cm' }}
+        />
+      </Page>
+    </Document>,
+  )
+
+  // pdf is a Binary — pass it to other activities, e.g. an http form upload:
+  // await http.post(url, { form: { file: pdf } })
+})
+```
+
+The returned `Binary` exposes `contentType` (`application/pdf`),
+`contentLength`, and `stream()`.
+
+---
+
+## Images
+
+`Image src` accepts three shapes:
+
+- **URL string** — fetched by react-pdf at layout time. Simple, but the fetch
+  happens on every render/replay and cannot authenticate.
+- **`data:` URI string** — for small assets bundled with the app.
+- **`Binary`** — the replay-safe choice for anything private or that must stay
+  byte-identical across replays. The bytes are inlined as a `data:` URI on the
+  activity side. Typical source: an `http` response body
+  (`response.body.binary`) or any other claim-produced `Binary`.
+
+Supported formats: PNG and JPEG.
+
+---
+
+## Fonts
+
+`render(element, { fonts })` — an object keyed by **family name**. The value
+is either a bare source (registers the regular 400/normal variant) or an
+array of variants:
+
+```tsx
+const pdf = await render(<Doc />, {
+  fonts: {
+    // bare source: string URL or Binary
+    Inter: 'https://cdn.example.com/Inter-Regular.ttf',
+    Geometric: fontResponse.body.binary,
+
+    // multiple weights/styles under one family
+    Roboto: [
+      { src: robotoRegular.body.binary },
+      { src: robotoBold.body.binary, weight: 700 },
+      { src: robotoItalic.body.binary, style: 'italic' },
+    ],
+  },
+})
+```
+
+Select variants in styles with `fontFamily` + `fontWeight` + `fontStyle`.
+Weights are `100–900`; styles `'normal' | 'italic'`.
+
+Rules of thumb:
+
+- **TTF and WOFF only** — react-pdf cannot parse WOFF2 (Google Fonts links
+  often point to WOFF2; pick the TTF URL).
+- Prefer `Binary` for private/licensed fonts and replay stability; a URL is a
+  mutable external reference fetched at layout time.
+- Fonts registered per render; same-family re-registration is safe.
+
+---
+
+## Encryption
+
+`render(element, { encrypt })` also persists a password-protected copy and
+resolves with an `[original, encrypted]` tuple — the return type narrows
+automatically:
+
+```tsx
+const [original, encrypted] = await render(<Invoice />, {
+  encrypt: {
+    password: customer.documentNumber,
+    protection: ProtectionPresets.ReadOnly,
+  },
+})
+```
+
+- `password`: a bare string (same password opens and owns the file) or
+  `{ user, owner }` for a distinct owner password that bypasses permission
+  restrictions.
+- `protection`: a `ProtectionFlags` bitmask granted to whoever opens with the
+  user password. Combine flags with `|` (`Print`, `Modify`, `CopyAndExtract`,
+  `AnnotateAndFill`, `FillForms`, `ExtractForAccessibility`, `Assemble`,
+  `PrintHighResolution`) or use a preset: `ProtectionPresets.ReadOnly`
+  (view + print only — invoices, statements) or `ProtectionPresets.All`.
+- Permission flags are honored by PDF viewers, **not enforced
+  cryptographically** — the open password is the only real protection.
+- Encryption is **only** available through `render`'s `encrypt` option. Never
+  import from `src/tools/encrypt-pdf.js` — it is internal and not exported.
+
+---
+
+## Testing
+
+Test the **workflow** with `TestWorkflowEnvironment` from
+`@t4h.framework/core/testing`, mocking the single claim the render activity
+uses: `FileSystemClaim`. See the **framework-workflow-testing** skill for the
+harness API.
+
+```typescript
+import { Readable } from 'node:stream'
+import { Binary } from '@t4h.framework/core'
+import { TestWorkflowEnvironment, mockClaim } from '@t4h.framework/core/testing'
+import { FileSystemClaim } from '@t4h.framework/fs'
+
+class MockBinary extends Binary {
+  public readonly contentType = 'application/pdf'
+  public readonly contentLength: number
+
+  constructor(private readonly data: Buffer) {
+    super()
+    this.contentLength = data.byteLength
+  }
+
+  public stream() {
+    return Readable.from(this.data)
+  }
+}
+
+const mockWrite = vi.fn().mockImplementation(async (_path, pdf: Buffer) => {
+  return new MockBinary(pdf)
+})
+
+const env = TestWorkflowEnvironment.create({ now: 0 })
+
+await env.execute(workflow, input, {
+  claims: [mockClaim(FileSystemClaim, { write: mockWrite, read: vi.fn() })],
+})
+
+// The activity hands the rendered buffer to fs.write — assert on it:
+const [path, pdf] = mockWrite.mock.calls[0]
+expect(path).toMatch(/^pdf\/.+\.pdf$/)
+expect(pdf.subarray(0, 5).toString()).toBe('%PDF-')
+```
+
+For helper-level tests (serialization, element mapping, fonts), see
+`src/helpers/__tests__/` — they assert on the `DocumentNode` JSON shape and on
+react-pdf element trees without rendering.
+
+---
+
+## Checklist for agents
+
+1. In workflows, **always** use **`render()`** — never define, extend, or
+   hand-instantiate `RenderPDFActivity`.
+2. Build templates with the **marker components from this package** — never
+   import `Document`/`Page`/etc. from `@react-pdf/renderer` in workflow code,
+   and never call a marker as a function.
+3. Wrap every raw string in **`Text`**; only `Text`/`Link`/`PageNumber` go
+   inside `Text`; `Document` children are `Page` only.
+4. Ensure the runtime provides **`FileSystemClaim`** (or mock it in tests) —
+   the rendered PDF is persisted through it and returned as a `Binary`.
+5. Prefer **`Binary`** sources for images and fonts that must be private or
+   replay-stable; URLs are fetched at layout time on every render.
+6. Fonts: object keyed by family, **TTF/WOFF only**, select variants via
+   `fontFamily`/`fontWeight`/`fontStyle`.
+7. Style with the **flex model** (`PDFStyle`, camelCase, points or unit
+   strings); put inheritable text defaults on `Page`.
+8. Use `fixed` + absolute positioning for running headers/footers and
+   `PageNumber` for pagination stamps.
+9. Password-protect PDFs **only** via `render`'s `encrypt` option — it
+   returns `[original, encrypted]`. Never import the internal `encryptPDF`
+   tool. Remember permission flags are viewer-honored, not cryptographic.
+10. Test workflows with **`TestWorkflowEnvironment`** + **`mockClaim`**,
+    asserting the `%PDF-` magic bytes on the `fs.write` call.
+11. Do not document or import APIs not exported from `@t4h.framework/pdf`
+    (the `helpers/` and `tools/` modules are internal).
+
+See also: **framework-workflow-testing** for the test harness;
+**framework-fs** for `FileSystemClaim`; **framework-http** for fetching
+`Binary` assets (images, fonts) used in templates.

package/CHANGELOG.md

@@ -0,0 +1,35 @@
+# @t4h.framework/pdf
+
+## 0.0.0-experimental-20260907052843
+
+### Patch Changes
+
+- Updated dependencies [[`a30386e`](https://github.com/tech4humans-brasil/framework/commit/a30386ebf832d1eec5989b0a12a56d91a6999421)]:
+  - @t4h.framework/core@0.0.0-experimental-20260907052843
+  - @t4h.framework/fs@0.0.0-experimental-20260907052843
+
+## 0.2.1
+
+### Patch Changes
+
+- Re-releases the accidental `1.0.0` as a patch. `1.0.0` was published by mistake (changesets bumps peer dependents with a major when a peer dependency gets a minor bump); this package stays on the `0.x` line.
+- Updated dependencies [[`8c56f76`](https://github.com/tech4humans-brasil/framework/commit/8c56f7697390a1ea966d1e91ff5f35ce5751a0d7), [`8c56f76`](https://github.com/tech4humans-brasil/framework/commit/8c56f7697390a1ea966d1e91ff5f35ce5751a0d7)]:
+  - @t4h.framework/fs@0.8.0
+
+## 0.2.0
+
+### Minor Changes
+
+- [`389e0b7`](https://github.com/tech4humans-brasil/framework/commit/389e0b72b5025dc85f33b371c320a3821314d41e) Thanks [@gusteycamargo](https://github.com/gusteycamargo)! - Adds encryption option
+
+## 0.1.1
+
+### Patch Changes
+
+- [`095c3a9`](https://github.com/tech4humans-brasil/framework/commit/095c3a91191b9f541519447f212a8e9509065569) Thanks [@gusteycamargo](https://github.com/gusteycamargo)! - Republish with resolved dependency versions. The previous release leaked the `workspace:^` protocol into the published manifests, breaking installs outside the monorepo.
+
+## 0.1.0
+
+### Minor Changes
+
+- [`dd3bc50`](https://github.com/tech4humans-brasil/framework/commit/dd3bc508e295e531bf59ce2909fc22b3b4355d2c) Thanks [@gusteycamargo](https://github.com/gusteycamargo)! - Initialize package

package/README.md

@@ -0,0 +1,175 @@
+# @t4h.framework/pdf
+
+Declarative PDF rendering for workflows. Build documents with JSX components, render them replay-safely through the workflow history, and get back a `Binary` persisted via the filesystem claim. Backed by [`@react-pdf/renderer`](https://react-pdf.org).
+
+## Claim
+
+### FileSystemClaim
+
+The render activity persists the generated PDF through `FileSystemClaim` (from `@t4h.framework/fs`) and returns the resulting `Binary`. The runtime must provide a concrete implementation.
+
+```typescript
+import { FileSystemClaim } from '@t4h.framework/fs'
+
+// the runtime provides this:
+// { provide: FileSystemClaim, value: new MyFileSystemClaimImpl() }
+```
+
+## Rendering
+
+### render
+
+Renders a JSX tree to a PDF `Binary` through the workflow history. The tree is serialized into the history on the workflow side and rendered on the activity side, so the step is replay-safe.
+
+```tsx
+import { Workflow } from '@t4h.framework/core'
+import { Document, Page, Text, render } from '@t4h.framework/pdf'
+
+export const invoice = new Workflow({ id: 'invoice' }, async () => {
+  const pdf = await render(
+    <Document title='Invoice'>
+      <Page size='A4' style={{ padding: '2cm', fontSize: 12 }}>
+        <Text>Hello world</Text>
+      </Page>
+    </Document>,
+  )
+
+  // pdf is a Binary — hand it to other activities, e.g. an upload:
+  // await http.post(url, { form: { file: pdf } })
+})
+```
+
+The returned `Binary` exposes `contentType` (`application/pdf`), `contentLength`, and `stream()`.
+
+## Components
+
+The components exported by this package are **markers**: type-safe JSX tags that only exist inside a tree passed to `render()`. They are never invoked as functions — calling one directly or rendering it with another renderer throws.
+
+| Component | Key props | Description |
+|-----------|-----------|-------------|
+| `Document` | `title`, `author`, `subject`, `language` | Root of the PDF. Children must be `Page` elements |
+| `Page` | `size` (default `A4`), `orientation`, `style`, `dpi` | A page. Overflowing content paginates automatically |
+| `View` | — | Flex container, analogous to a `<div>` |
+| `Text` | — | Text content. All raw strings must live inside a `Text` |
+| `Link` | `href` | Hyperlink |
+| `Image` | `src` | Image from a URL, `data:` URI, or `Binary` |
+| `PageNumber` | `format` | Text resolved to the current page number at layout time |
+
+Every node inside a page also accepts: `style`, `fixed` (repeat on every page), `break` (force a page break), `wrap` (allow splitting across pages, default `true`), and `minPresenceAhead`.
+
+User function components, `.map()` arrays, fragments, and conditional rendering work exactly like normal React:
+
+```tsx
+function LineItem({ label, value }: { label: string; value: string }) {
+  return (
+    <View style={{ flexDirection: 'row', justifyContent: 'space-between' }}>
+      <Text>{label}</Text>
+      <Text>{value}</Text>
+    </View>
+  )
+}
+
+const pdf = await render(
+  <Document>
+    <Page size='A4'>
+      {items.map(item => (
+        <LineItem key={item.id} {...item} />
+      ))}
+      {showFooter && <Text>Footer</Text>}
+    </Page>
+  </Document>,
+)
+```
+
+Tree rules enforced at serialization (violations throw):
+
+- The tree must resolve to a single `Document` root, and `Document` children must be `Page` elements.
+- Raw text must be wrapped in `Text`.
+- Only `Text`, `Link`, and `PageNumber` are allowed inside `Text`.
+
+## Styling
+
+Styles are camelCase records following the CSS **flex model** (no grid, no float). Numbers are points; strings accept units (`'2cm'`, `'5mm'`, `'50%'`). Text styles inherit through the tree, so defaults belong on `Page`.
+
+```tsx
+<Page size='A4' style={{ padding: '2cm', fontSize: 12, color: '#00513a' }}>
+  <View style={{ flexDirection: 'row', gap: 8 }}>
+    <Text style={{ fontWeight: 'bold' }}>Bold</Text>
+    <Text style={[{ fontSize: 10 }, { color: '#666' }]}>Small and gray</Text>
+  </View>
+</Page>
+```
+
+The standard PDF fonts (Helvetica, Courier, Times-Roman) are available with no registration, including `bold` and `italic` variants.
+
+## Images
+
+`Image src` accepts a URL, a `data:` URI, or a `Binary` whose `contentType` is an image type (PNG or JPEG). Prefer `Binary` for anything private or that must stay byte-identical across replays — URLs are fetched at layout time on every render.
+
+```tsx
+const logo = await http.get('https://cdn.example.com/logo.png')
+
+<Image src={logo.body.binary} style={{ width: 120 }} />
+```
+
+## Fonts
+
+Register custom fonts per render with an object keyed by family name. Values are a bare source — a URL string or a `Binary` — for the regular variant, or an array of variants with `weight` / `style`. TTF and WOFF only (no WOFF2).
+
+```tsx
+const pdf = await render(<Doc />, {
+  fonts: {
+    Inter: 'https://cdn.example.com/Inter-Regular.ttf',
+    Roboto: [
+      { src: robotoRegular.body.binary },
+      { src: robotoBold.body.binary, weight: 700 },
+      { src: robotoItalic.body.binary, style: 'italic' },
+    ],
+  },
+})
+```
+
+Select variants in styles with `fontFamily`, `fontWeight` (`100–900`), and `fontStyle` (`'normal' | 'italic'`).
+
+## Encryption
+
+Pass `encrypt` to also persist a password-protected copy — `render` then resolves with an `[original, encrypted]` pair (the return type narrows automatically). `password` is a bare string or `{ user, owner }`; `protection` is a `ProtectionFlags` bitmask (defaults follow the viewer; use `ProtectionPresets.ReadOnly` for view-and-print documents). Permission flags are honored by viewers, not enforced cryptographically.
+
+```tsx
+import { ProtectionPresets, render } from '@t4h.framework/pdf'
+
+const [original, encrypted] = await render(<Invoice />, {
+  encrypt: { password: '12345678900', protection: ProtectionPresets.ReadOnly },
+})
+```
+
+## Page numbers
+
+`PageNumber` resolves at layout time. The `format` string may reference `{pageNumber}` and `{totalPages}`; combine with `fixed` and absolute positioning for running footers.
+
+```tsx
+<PageNumber
+  fixed
+  format='{pageNumber}/{totalPages}'
+  style={{ position: 'absolute', bottom: 24, right: '2cm' }}
+/>
+```
+
+## Testing
+
+Test workflows with `TestWorkflowEnvironment` from `@t4h.framework/core/testing`, mocking `FileSystemClaim` — the rendered buffer is handed to `fs.write`, so assert on the `%PDF-` magic bytes there:
+
+```typescript
+import { TestWorkflowEnvironment, mockClaim } from '@t4h.framework/core/testing'
+import { FileSystemClaim } from '@t4h.framework/fs'
+
+const mockWrite = vi.fn().mockImplementation(async (_path, pdf) => new MockBinary(pdf))
+
+const env = TestWorkflowEnvironment.create({ now: 0 })
+
+await env.execute(workflow, input, {
+  claims: [mockClaim(FileSystemClaim, { write: mockWrite, read: vi.fn() })],
+})
+
+expect(mockWrite.mock.calls[0][1].subarray(0, 5).toString()).toBe('%PDF-')
+```

package/dist/activities/RenderPDFActivity.d.ts

@@ -0,0 +1,26 @@
+import { Binary, SyncActivity } from '@t4h.framework/core';
+import type { ReactElement } from 'react';
+import { type Fonts } from '../helpers/register-fonts.js';
+import { type EncryptPDFOptions } from '../tools/encrypt-pdf.js';
+import type { DocumentNode } from '../typings/pdf.js';
+export type RenderPDFOptions = {
+    fonts?: Fonts;
+    encrypt?: EncryptPDFOptions;
+};
+export type RenderPDFInput = {
+    document: DocumentNode;
+} & RenderPDFOptions;
+export declare class RenderPDFActivity extends SyncActivity<readonly [element: ReactElement, options?: RenderPDFOptions], RenderPDFInput, Binary | [Binary, Binary], Binary | [Binary, Binary]> {
+    private readonly claims;
+    toInput(element: ReactElement, options?: RenderPDFOptions): RenderPDFInput;
+    run(input: RenderPDFInput): Promise<Binary | [Binary, Binary]>;
+    toOutput(output: Binary | [Binary, Binary]): Binary | [Binary, Binary];
+}
+export declare function render(element: ReactElement, options: RenderPDFOptions & {
+    encrypt: EncryptPDFOptions;
+}): Promise<[original: Binary, encrypted: Binary]>;
+export declare function render(element: ReactElement, options?: RenderPDFOptions & {
+    encrypt?: undefined;
+}): Promise<Binary>;
+export declare function render(element: ReactElement, options?: RenderPDFOptions): Promise<Binary | [Binary, Binary]>;
+//# sourceMappingURL=RenderPDFActivity.d.ts.map

package/dist/activities/RenderPDFActivity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RenderPDFActivity.d.ts","sourceRoot":"","sources":["../../src/activities/RenderPDFActivity.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAkB,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAE1E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,OAAO,CAAA;AAIzC,OAAO,EAAiB,KAAK,KAAK,EAAE,MAAM,8BAA8B,CAAA;AACxE,OAAO,EAAc,KAAK,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAC5E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAErD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,CAAC,EAAE,KAAK,CAAA;IACb,OAAO,CAAC,EAAE,iBAAiB,CAAA;CAC5B,CAAA;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,EAAE,YAAY,CAAA;CACvB,GAAG,gBAAgB,CAAA;AAEpB,qBAAa,iBAAkB,SAAQ,YAAY,CACjD,SAAS,CAAC,OAAO,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,gBAAgB,CAAC,EAC5D,cAAc,EACd,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EACzB,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAC1B;IACC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqC;IAErD,OAAO,CACZ,OAAO,EAAE,YAAY,EACrB,OAAO,CAAC,EAAE,gBAAgB,GACzB,cAAc;IAQJ,GAAG,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAmBpE,QAAQ,CACb,MAAM,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAChC,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;CAG7B;AAED,wBAAsB,MAAM,CAC1B,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,gBAAgB,GAAG;IAAE,OAAO,EAAE,iBAAiB,CAAA;CAAE,GACzD,OAAO,CAAC,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC,CAAA;AACjD,wBAAsB,MAAM,CAC1B,OAAO,EAAE,YAAY,EACrB,OAAO,CAAC,EAAE,gBAAgB,GAAG;IAAE,OAAO,CAAC,EAAE,SAAS,CAAA;CAAE,GACnD,OAAO,CAAC,MAAM,CAAC,CAAA;AAClB,wBAAsB,MAAM,CAC1B,OAAO,EAAE,YAAY,EACrB,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA"}

package/dist/activities/RenderPDFActivity.js

@@ -0,0 +1,35 @@
+import { renderToBuffer } from '@react-pdf/renderer';
+import { Binary, Claim, History, SyncActivity } from '@t4h.framework/core';
+import { FileSystemClaim } from '@t4h.framework/fs';
+import { documentToElement } from '../helpers/document-to-element.js';
+import { elementToDocument } from '../helpers/element-to-document.js';
+import { registerFonts } from '../helpers/register-fonts.js';
+import { encryptPDF } from '../tools/encrypt-pdf.js';
+export class RenderPDFActivity extends SyncActivity {
+    claims = new Claim({ fs: FileSystemClaim });
+    toInput(element, options) {
+        return {
+            document: elementToDocument(element),
+            fonts: options?.fonts,
+            encrypt: options?.encrypt,
+        };
+    }
+    async run(input) {
+        if (input.fonts)
+            await registerFonts(input.fonts);
+        const element = await documentToElement(input.document);
+        const pdf = await renderToBuffer(element);
+        const original = await this.claims.fs.write(`pdf/${this.id}.pdf`, pdf);
+        if (!input.encrypt)
+            return original;
+        const encrypted = await this.claims.fs.write(`pdf/${this.id}-encrypted.pdf`, encryptPDF(pdf, input.encrypt));
+        return [original, encrypted];
+    }
+    toOutput(output) {
+        return output;
+    }
+}
+export async function render(element, options) {
+    return await History.reconciler(RenderPDFActivity, element, options);
+}
+//# sourceMappingURL=RenderPDFActivity.js.map

package/dist/activities/RenderPDFActivity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RenderPDFActivity.js","sourceRoot":"","sources":["../../src/activities/RenderPDFActivity.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAC1E,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAGnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAA;AACrE,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAA;AACrE,OAAO,EAAE,aAAa,EAAc,MAAM,8BAA8B,CAAA;AACxE,OAAO,EAAE,UAAU,EAA0B,MAAM,yBAAyB,CAAA;AAY5E,MAAM,OAAO,iBAAkB,SAAQ,YAKtC;IACkB,MAAM,GAAG,IAAI,KAAK,CAAC,EAAE,EAAE,EAAE,eAAe,EAAE,CAAC,CAAA;IAErD,OAAO,CACZ,OAAqB,EACrB,OAA0B;QAE1B,OAAO;YACL,QAAQ,EAAE,iBAAiB,CAAC,OAAO,CAAC;YACpC,KAAK,EAAE,OAAO,EAAE,KAAK;YACrB,OAAO,EAAE,OAAO,EAAE,OAAO;SAC1B,CAAA;IACH,CAAC;IAEM,KAAK,CAAC,GAAG,CAAC,KAAqB;QACpC,IAAI,KAAK,CAAC,KAAK;YAAE,MAAM,aAAa,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;QAEjD,MAAM,OAAO,GAAG,MAAM,iBAAiB,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAA;QAEvD,MAAM,GAAG,GAAG,MAAM,cAAc,CAAC,OAAO,CAAC,CAAA;QAEzC,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,CAAA;QAEtE,IAAI,CAAC,KAAK,CAAC,OAAO;YAAE,OAAO,QAAQ,CAAA;QAEnC,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,CAC1C,OAAO,IAAI,CAAC,EAAE,gBAAgB,EAC9B,UAAU,CAAC,GAAG,EAAE,KAAK,CAAC,OAAO,CAAC,CAC/B,CAAA;QAED,OAAO,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAA;IAC9B,CAAC;IAEM,QAAQ,CACb,MAAiC;QAEjC,OAAO,MAAM,CAAA;IACf,CAAC;CACF;AAcD,MAAM,CAAC,KAAK,UAAU,MAAM,CAC1B,OAAqB,EACrB,OAA0B;IAE1B,OAAO,MAAM,OAAO,CAAC,UAAU,CAAC,iBAAiB,EAAE,OAAO,EAAE,OAAO,CAAC,CAAA;AACtE,CAAC"}