@uniweb/press 0.4.7 → 0.4.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/press",
-  "version": "0.4.7",
+  "version": "0.4.8",
   "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/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)

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,
     }