@uniweb/press 0.4.1 → 0.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/press",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "Press your React components into downloadable files — Word, Excel, PDF. Registration-based pattern with lazy-loaded format adapters.",
   "type": "module",
   "exports": {

package/src/adapters/docx.js

@@ -129,8 +129,13 @@ export async function buildDocument(input, options = {}) {
     if (footer) collectFootnotes(footer, footnotesState)
 
     // Flatten all blocks' IR trees into one array of section children.
-    // Use async conversion for image support.
-    const children = await convertChildren(sections.flat())
+    // Use async conversion for image support. The host-supplied loadAsset
+    // (when present) is threaded down to irToImageParagraph → fetchImageData
+    // → fetchAsset, so config-level paths like `assets/diagram.png` resolve
+    // to bytes via the framework's content-collector manifest the same way
+    // the typst path does.
+    const { loadAsset } = options
+    const children = await convertChildren(sections.flat(), loadAsset)
 
     const sectionOptions = {
         properties: {
@@ -144,7 +149,7 @@ export async function buildDocument(input, options = {}) {
     }
 
     if (header) {
-        const headerChildren = await convertChildren(header)
+        const headerChildren = await convertChildren(header, loadAsset)
         const headerObj = new Header({ children: headerChildren })
         const defaultHeaderObj = createDefaultHeaderFooter(true)
 
@@ -160,7 +165,7 @@ export async function buildDocument(input, options = {}) {
     }
 
     if (footer) {
-        const footerChildren = await convertChildren(footer)
+        const footerChildren = await convertChildren(footer, loadAsset)
         const footerObj = new Footer({ children: footerChildren })
         const defaultFooterObj = createDefaultHeaderFooter(false)
 
@@ -280,10 +285,14 @@ export function createDefaultHeaderFooter(isHeader) {
 
 /**
  * Convert an array of IR nodes to section children, handling async
- * image fetches via Promise.all.
+ * image fetches via Promise.all. `loadAsset` (when provided) is forwarded
+ * to image-emitting paths so host-supplied byte loaders take precedence
+ * over the URL-based fetch fallback.
  */
-async function convertChildren(nodes) {
-    const results = await Promise.all(nodes.map(irToSectionChildrenAsync))
+async function convertChildren(nodes, loadAsset) {
+    const results = await Promise.all(
+        nodes.map((node) => irToSectionChildrenAsync(node, loadAsset)),
+    )
     return results.flat()
 }
 
@@ -294,12 +303,12 @@ async function convertChildren(nodes) {
 /**
  * Convert an IR node into section-level docx children (async for images).
  */
-async function irToSectionChildrenAsync(node) {
+async function irToSectionChildrenAsync(node, loadAsset) {
     switch (node.type) {
         case 'table':
             return [await irToTableAsync(node)]
         case 'image':
-            return [await irToImageParagraph(node)]
+            return [await irToImageParagraph(node, loadAsset)]
         case 'tableOfContents':
             return [irToTableOfContents(node)]
         case 'webOnly':
@@ -804,12 +813,12 @@ function inferImageType(src, data) {
  * valid type). Do not simplify the altText spread — `name: ''` looks
  * like a no-op but Word-for-Mac rejects the file without it.
  */
-async function irToImageParagraph(node) {
+async function irToImageParagraph(node, loadAsset) {
     try {
         const src = node.src || ''
         if (!src) return new DocxParagraph({})
 
-        const imageData = await fetchImageData(src)
+        const imageData = await fetchImageData(src, loadAsset)
 
         const width = toInt(node.transformation?.width) ?? 400
         const height = toInt(node.transformation?.height) ?? 300
@@ -847,7 +856,7 @@ async function irToImageParagraph(node) {
  * adapter use; see principle 6 ("Extract shared logic when a second
  * adapter needs it") in docs/architecture/principles.md.
  */
-async function fetchImageData(url) {
-    const { bytes } = await fetchAsset(url)
+async function fetchImageData(url, loadAsset) {
+    const { bytes } = await fetchAsset(url, { loadAsset })
     return bytes
 }

package/src/adapters/epub.js

@@ -59,7 +59,7 @@ import { fetchAssets } from '../assets/fetch.js'
  */
 export async function compileEpub(input, options = {}) {
     const { sections = [], metadata = null } = input || {}
-    const { meta = {}, stylesheet, identifier, cover } = options
+    const { meta = {}, stylesheet, identifier, cover, loadAsset } = options
 
     const resolvedMeta = { ...(metadata || {}), ...meta }
     const css = stylesheet || DEFAULT_STYLESHEET
@@ -74,13 +74,17 @@ export async function compileEpub(input, options = {}) {
     // Deduplicate image URLs across all chapters — and the cover, if any —
     // and fetch them in parallel. Failed fetches are logged and the original
     // URL is left in place; the EPUB still opens but may show broken images.
+    // The host-supplied `loadAsset` (when present) is tried before fetch —
+    // browser hosts wrap fetch; Node hosts (unipress) wrap node:fs so config-
+    // level paths like `assets/cover.jpg` resolve to bytes via the manifest
+    // the framework's content collector populated.
     const imageUrls = new Set()
     for (const ch of chapters) {
         for (const url of ch.images) imageUrls.add(url)
     }
     if (coverUrl) imageUrls.add(coverUrl)
     const fetched = imageUrls.size
-        ? await fetchAssets(imageUrls)
+        ? await fetchAssets(imageUrls, { loadAsset })
         : new Map()
 
     // Assign a manifest-relative path to every successfully-fetched image,

package/src/assets/fetch.js

@@ -22,16 +22,47 @@
 /**
  * Fetch a single asset URL and return normalized bytes + metadata.
  *
+ * Resolution order:
+ *   1. `options.loadAsset(url)` — host-supplied byte loader. Browser hosts
+ *      typically wrap `fetch`; Node hosts (unipress) wrap `node:fs`. When
+ *      present, tried first; on throw or null/undefined return, falls
+ *      through to `fetch`. This is how foundations stay environment-
+ *      agnostic — they declare `book.covers.front: assets/front.jpg` and
+ *      the host's loadAsset turns that into bytes the same way the host
+ *      handles every other config-level asset.
+ *   2. `fetch()` (or `options.fetch` for tests) — the legacy URL-based
+ *      path. Required for absolute http(s) URLs and as a fallback for
+ *      anything `loadAsset` can't handle.
+ *
  * @param {string} url
  * @param {Object} [options]
+ * @param {(src: string) => Promise<Uint8Array | null>} [options.loadAsset]
+ *   - host-supplied byte loader. See above.
  * @param {typeof fetch} [options.fetch] - override for tests / node-fetch.
  * @returns {Promise<{ bytes: Uint8Array, mime: string, hash: string, ext: string }>}
  */
 export async function fetchAsset(url, options = {}) {
+    const { loadAsset } = options
+
+    if (typeof loadAsset === 'function') {
+        try {
+            const bytes = await loadAsset(url)
+            if (bytes && bytes.length > 0) {
+                const mime = detectMime(url, bytes)
+                const ext = extForMime(mime) || extFromUrl(url) || 'bin'
+                const hash = await hashContent(bytes)
+                return { bytes, mime, hash, ext }
+            }
+        } catch {
+            // Fall through to fetch — loadAsset may not handle every URL
+            // shape (e.g., absolute http(s) URLs in a Node host).
+        }
+    }
+
     const fetchImpl = options.fetch || globalThis.fetch
     if (typeof fetchImpl !== 'function') {
         throw new Error(
-            'fetchAsset: no fetch() available. Pass options.fetch or run in an environment that provides globalThis.fetch.',
+            'fetchAsset: no fetch() available. Pass options.fetch / options.loadAsset or run in an environment that provides globalThis.fetch.',
         )
     }
     const res = await fetchImpl(url)