@uniweb/press 0.4.7 → 0.4.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/press",
-  "version": "0.4.7",
+  "version": "0.4.9",
   "description": "Press your React components into downloadable files — Word, Excel, PDF. Registration-based pattern with lazy-loaded format adapters.",
   "type": "module",
   "exports": {
@@ -46,8 +46,8 @@
     "parse5": "^7.2.0"
   },
   "peerDependencies": {
-    "react": "^18.0.0 || ^19.0.0",
-    "react-dom": "^18.0.0 || ^19.0.0"
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
   },
   "devDependencies": {
     "@testing-library/react": "^16.0.0",

package/src/adapters/docx.js

@@ -510,6 +510,9 @@ function irToInlineChildren(node) {
             // a TextRun so the OOXML parent is <w:r>.
             return [new TextRun({ children: [new DocxTab()] })]
         case 'externalHyperlink':
+        // A plain <a href> from same-source JSX — same destination, same
+        // emitter. See the href note in ir/parser.js.
+        case 'a':
             return [irToExternalHyperlink(node)]
         case 'internalHyperlink':
             return [irToInternalHyperlink(node)]
@@ -612,10 +615,13 @@ function irToTextRunPair(node) {
 }
 
 function irToExternalHyperlink(node) {
+    // `link` is the data-* spelling (data-link); `href` arrives from a plain
+    // <a href>. Same destination either way.
+    const destination = node.link || node.href || ''
     const children = (node.children || []).flatMap(irToInlineChildren)
     return new ExternalHyperlink({
-        children: children.length ? children : [new TextRun({ text: node.link || '' })],
-        link: node.link || '',
+        children: children.length ? children : [new TextRun({ text: destination })],
+        link: destination,
     })
 }
 

package/src/adapters/latex.js

@@ -47,6 +47,7 @@
  */
 
 import JSZip from 'jszip'
+import { bundleInlineImages } from '../assets/inline-images.js'
 import { RAW_BEGIN, RAW_END, markRawLatex } from '../latex/raw.js'
 
 // Re-export so consumers reaching the adapter via the dynamic-import
@@ -84,9 +85,18 @@ export { markRawLatex }
  * @returns {Promise<Blob>}
  */
 export async function compileLatex(input, options = {}) {
-    const { mode = 'sources', ...rest } = options
-
-    const bundle = buildBundle(input, rest)
+    const { mode = 'sources', loadAsset, ...rest } = options
+
+    // Fetch inline body images and rewrite their IR src to a bundle-local
+    // assets/<hash>.<ext> path, then merge the bytes into the bundle so
+    // latexmk/pdflatex resolves \includegraphics{...} against the extracted
+    // sources. Cover art arrives pre-bundled in rest.assets via the
+    // foundation's getOptions; this handles document-body images.
+    const inlineImageAssets = await bundleInlineImages(input, loadAsset)
+    const bundle = buildBundle(input, {
+        ...rest,
+        assets: { ...(rest.assets || {}), ...inlineImageAssets },
+    })
 
     if (mode === 'sources') {
         return zipBundle(bundle)

package/src/adapters/typst.js

@@ -28,6 +28,7 @@
  */
 
 import JSZip from 'jszip'
+import { bundleInlineImages } from '../assets/inline-images.js'
 
 // ============================================================================
 // Public API
@@ -53,9 +54,18 @@ import JSZip from 'jszip'
  * @returns {Promise<Blob>}
  */
 export async function compileTypst(input, options = {}) {
-    const { mode = 'sources', ...rest } = options
-
-    const bundle = buildBundle(input, rest)
+    const { mode = 'sources', loadAsset, ...rest } = options
+
+    // Fetch inline body images (`![](foo.png)`) and rewrite their IR src to a
+    // bundle-local `assets/<hash>.<ext>` path, then merge the bytes into the
+    // bundle so `typst compile` resolves them. Cover images arrive pre-bundled
+    // in rest.assets via the foundation's getOptions; this handles the images
+    // an author drops into the document body.
+    const inlineImageAssets = await bundleInlineImages(input, loadAsset)
+    const bundle = buildBundle(input, {
+        ...rest,
+        assets: { ...(rest.assets || {}), ...inlineImageAssets },
+    })
 
     if (mode === 'sources') {
         return zipBundle(bundle)
@@ -364,6 +374,7 @@ function blockNodeToTypst(node) {
             return inlineNodeToTypst(node)
 
         case 'link':
+        case 'a':
             return inlineNodeToTypst(node)
 
         case 'math':
@@ -516,7 +527,7 @@ function inlineNodeToTypst(node) {
         return text
     }
 
-    if (node.type === 'link') {
+    if (node.type === 'link' || node.type === 'a') {
         const href = node.href || ''
         const inner = inlineChildrenToTypst(node.children || [])
         return `#link(${quoteTypstString(href)})[${inner}]`

package/src/assets/inline-images.js

@@ -0,0 +1,84 @@
+/**
+ * Inline image bundling for source-bundle adapters (typst, latex).
+ *
+ * A source-bundle adapter emits an image reference (`#image(src)`,
+ * `\includegraphics{src}`) into a text file and ships a directory of assets
+ * alongside it. The IR carries only the author's `src` string, so the bytes
+ * have to be fetched and written into the bundle — and the src rewritten to the
+ * bundle-local path — before `typst` / `latex` can resolve them. Cover images
+ * arrive pre-bundled via the foundation's getOptions; this handles the images
+ * an author drops into the document body.
+ *
+ * Extracted from the typst adapter when latex became the second bundle adapter
+ * needing it — principle 6 in docs/architecture/principles.md, the same reason
+ * src/assets/fetch.js exists. EPUB does its own image embedding (it needs OPF
+ * manifest entries and a different on-disk layout), so it doesn't share this.
+ */
+
+import { fetchAssets } from './fetch.js'
+
+/**
+ * Fetch every inline image referenced in the IR and rewrite its node `src` to a
+ * bundle-local `assets/<hash>.<ext>` path, returning the map of bundle files to
+ * merge into the source bundle.
+ *
+ * The format walker emits the (rewritten) src verbatim, so the compiler
+ * resolves it against the extracted bundle directory. Byte-loading goes through
+ * the shared fetchAssets helper: the host-supplied loadAsset (node:fs in
+ * unipress, fetch in the browser) turns a resolved src into bytes. Images that
+ * fail to load are left untouched so one missing asset doesn't abort the whole
+ * document.
+ *
+ * @param {Object} input - compileOutputs output ({ sections, header, footer }).
+ * @param {(src: string) => Promise<Uint8Array|null>} [loadAsset]
+ * @returns {Promise<Record<string, Uint8Array>>} bundlePath → bytes
+ */
+export async function bundleInlineImages(input, loadAsset) {
+    const imageNodes = collectImageNodes(input)
+    if (!imageNodes.length) return {}
+
+    const srcs = [...new Set(imageNodes.map((n) => n.src).filter(Boolean))]
+    if (!srcs.length) return {}
+
+    const fetched = await fetchAssets(srcs, { loadAsset })
+
+    const assets = {}
+    const rewrite = new Map()
+    for (const [src, result] of fetched) {
+        if (!result || result.error || !result.bytes) continue
+        const bundlePath = `assets/${result.hash}.${result.ext}`
+        assets[bundlePath] = result.bytes
+        rewrite.set(src, bundlePath)
+    }
+
+    // Rewrite the IR in place so the walker emits the bundle path. The IR is
+    // freshly built by compileOutputs for this compile, so mutation is safe and
+    // avoids threading a rewrite map through the whole walker.
+    for (const node of imageNodes) {
+        const bundlePath = rewrite.get(node.src)
+        if (bundlePath) node.src = bundlePath
+    }
+
+    return assets
+}
+
+/**
+ * Collect every image IR node reachable from the compiled input, descending
+ * through `children` (paragraphs, lists, tables, figures, …) across sections,
+ * header, and footer.
+ */
+export function collectImageNodes(input) {
+    const found = []
+    const visit = (nodes) => {
+        if (!Array.isArray(nodes)) return
+        for (const node of nodes) {
+            if (!node || typeof node !== 'object') continue
+            if (node.type === 'image') found.push(node)
+            if (Array.isArray(node.children)) visit(node.children)
+        }
+    }
+    for (const section of input?.sections || []) visit(section)
+    visit(input?.header || [])
+    visit(input?.footer || [])
+    return found
+}

package/src/compileRegistrations.js

@@ -276,6 +276,11 @@ export async function compileDocument(treeOrWebsite, options = {}) {
         : {}
 
     const mergedAdapterOptions = {
+        // Thread the host loadAsset through to the adapter so it can embed
+        // inline body images (the typst/latex bundlers fetch bytes here, the
+        // same capability the docx adapter uses). A foundation's getOptions or
+        // the caller can still override it via adapterOptions.
+        loadAsset,
         ...foundationAdapterOptions.adapterOptions,
         ...overrideAdapterOptions,
     }

package/src/ir/parser.js

@@ -103,6 +103,22 @@ function nodeToIR(node) {
     const properties = attributesToProperties(node.attrs || [])
     const children = collectChildren(node)
 
+    // A plain <a href> carries its destination in a normal HTML attribute, not
+    // a data-* one, so attributesToProperties drops it. Foundations reach this
+    // shape by writing an ordinary anchor in JSX that serves both the browser
+    // preview and the compile input — the same-source property principles.md
+    // §8 asks us to pursue. Without the href the adapters still emit the link
+    // TEXT and silently lose the destination, which is precisely the
+    // preview/output drift that principle exists to eliminate.
+    //
+    // Only `href` is lifted, and only for an anchor: it is the one plain
+    // attribute whose document meaning is unambiguous. The IR stays data-*
+    // driven everywhere else.
+    if (type === 'a' && properties.href === undefined) {
+        const href = getAttr(node, 'href')
+        if (href) properties.href = href
+    }
+
     const obj = { type, ...properties }
 
     if (type === 'text') {