@uniweb/semantic-parser 1.4.1 → 1.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/semantic-parser",
-  "version": "1.4.1",
+  "version": "1.5.0",
   "description": "Semantic parser for ProseMirror/TipTap content structures",
   "type": "module",
   "main": "./src/index.js",

package/src/builders/doc.js

@@ -116,6 +116,18 @@ function imageBlock({ src, url, alt = '', caption = '', direction, role, width,
   return { type: 'ImageBlock', attrs }
 }
 
+// A document is STORED as the image row with `role: 'pdf'` — the node the
+// markdown reader writes and the parser reads as a `document` — so that is what
+// this emits. `url` (the parser's spelling) or `src` (this builder's) in.
+function documentNode({ url, src, alt = '', caption = '', preview, author, description }) {
+  const attrs = { src: url || src, alt, role: 'pdf' }
+  if (caption) attrs.caption = caption
+  if (preview) attrs.preview = preview
+  if (author) attrs.author = author
+  if (description) attrs.description = description
+  return { type: 'image', attrs }
+}
+
 function iconNode({ src, url, svg, library, name, size, color }) {
   // UniwebIcon supports multiple source types.
   //
@@ -293,6 +305,12 @@ function buildGroupNodes(group, titleLevel = 1, options = {}) {
     }
   }
 
+  if (group.documents) {
+    for (const doc of group.documents) {
+      nodes.push(documentNode(doc))
+    }
+  }
+
   if (group.lists) {
     for (const list of group.lists) {
       const node = bulletList(list)

package/src/processors/groups.js

@@ -15,6 +15,7 @@ function flattenGroup(group) {
         icons: group.body.icons || [],
         lists: group.body.lists || [],
         videos: group.body.videos || [],
+        documents: group.body.documents || [],
         insets: group.body.insets || [],
         snippets: group.body.snippets || [],
         data: group.body.data || {},
@@ -303,6 +304,7 @@ function processGroupContent(elements, options = {}) {
         images: [],
         icons: [],
         videos: [],
+        documents: [],
         insets: [],
         snippets: [],
         paragraphs: [],
@@ -387,6 +389,10 @@ function processGroupContent(elements, options = {}) {
                     body.videos.push(preserveProps);
                     break;
 
+                case "document":
+                    body.documents.push(preserveProps);
+                    break;
+
                 case "link":
                     if (element.children && Array.isArray(element.children))
                         processInlineElements(element.children, body);
@@ -520,19 +526,6 @@ function processGroupContent(elements, options = {}) {
                     });
                     break;
 
-                case "document-group":
-                    // Map documents to links with role=document
-                    element.documents.forEach(doc => {
-                        body.links.push({
-                            href: doc.href || doc.downloadUrl || '',
-                            label: doc.title || '',
-                            role: 'document',
-                            download: true,
-                            preview: doc.coverImg,
-                            fileType: doc.fileType,
-                        });
-                    });
-                    break;
             }
         }
     }
@@ -588,6 +581,9 @@ function processInlineElements(children, body) {
             // `{role=video}` belongs in videos[] for the same reason a hoisted
             // one does.
             body.videos.push(item.attrs);
+        } else if (item.type === "document") {
+            // And an inline `{role=pdf}` in documents[].
+            body.documents.push(item.attrs);
         } else if (item.type === "link") {
             // Handle inline links extracted from paragraph text nodes
             body.links.push(item.attrs);

package/src/processors/sequence.js

@@ -210,7 +210,19 @@ function createSequenceElement(node, options = {}) {
         case "image":
             // `role` decides which content array this lands in — the contract
             // published in docs/reference/content-structure.md ("Media Assets"):
-            // icon → icons, video → videos, everything else → images.
+            // icon → icons, video → videos, pdf → documents, everything else →
+            // images.
+            //
+            // A document is stored as this node, as a video is, and delivered as
+            // a kind of its own (`parseMarkdownDocument`). Until 2026-09-29 it
+            // landed in `images`, drawn as an image of the file, while the
+            // runtime had guaranteed an empty `content.documents` since January.
+            if (attrs?.role === "pdf") {
+                return {
+                    type: "document",
+                    attrs: parseMarkdownDocument(attrs, options),
+                };
+            }
             //
             // The video branch was missing until 2026-07-30: every
             // `{role=video}` node ran parseImgBlock, which does not carry
@@ -315,13 +327,16 @@ function createSequenceElement(node, options = {}) {
             };
 
         case "document-group":
-            return {
-                type: "document-group",
-                documents:
-                    node.content
-                        ?.filter((c) => c.type === "document")
-                        .map((doc) => parseDocumentBlock(doc.attrs)) || [],
-            };
+            // The editor's older container: one `document` element per document
+            // it holds, so a document is one kind of content whichever node
+            // wrote it (`documentFromEditorNode`). Until 2026-09-29 this was a
+            // `document-group` element whose documents became `content.links`.
+            return (node.content || [])
+                .filter((c) => c.type === "document")
+                .map((doc) => ({
+                    type: "document",
+                    attrs: documentFromEditorNode(doc.attrs),
+                }));
 
         // The editor renamed this node to `StructuredContent` (2026-07-31,
         // editor-internal). Both are accepted: the new name is what the editor
@@ -613,13 +628,15 @@ function processInlineElements(content, options = {}) {
             // image silently deleted. groups.js has carried the receiving
             // branch (and a comment describing exactly this failure) since it
             // was written, but nothing ever emitted the item it reads.
-            const isVideo = item.attrs?.role === "video";
-            items.push({
-                type: isVideo ? "video" : "image",
-                attrs: isVideo
-                    ? parseMarkdownVideo(item.attrs, options)
-                    : parseImgBlock(item.attrs || {}, options),
-            });
+            // The role partitions it as the block case does.
+            const role = item.attrs?.role;
+            if (role === "video") {
+                items.push({ type: "video", attrs: parseMarkdownVideo(item.attrs, options) });
+            } else if (role === "pdf") {
+                items.push({ type: "document", attrs: parseMarkdownDocument(item.attrs, options) });
+            } else {
+                items.push({ type: "image", attrs: parseImgBlock(item.attrs || {}, options) });
+            }
         } else if (item.type === "math-inline" || item.type === "math_inline") {
             items.push(item);
         } else if (item.type === "inset_placeholder") {
@@ -802,6 +819,54 @@ function parseCardBlock(itemAttrs) {
     };
 }
 
+// A document authored in markdown: `![Annual report](./report.pdf){role=pdf …}`.
+//
+// Read through `parseImgBlock`, which resolves the address and the preview's the
+// way every image's are, and then narrowed to what a document IS: where the file
+// is, what it is called, and the resource's own metadata. The image layout keys
+// (direction, size, credit) describe a picture, not a file, and are left out.
+function parseMarkdownDocument(itemAttrs, options) {
+    const { url, alt, caption, role, href, target, id, preview, author, description } =
+        parseImgBlock(itemAttrs || {}, options);
+    return {
+        url,
+        alt,
+        caption,
+        role,
+        ...(href && { href }),
+        ...(target && { target }),
+        ...(id && { id }),
+        ...(preview && { preview }),
+        ...(author && { author }),
+        ...(description && { description }),
+    };
+}
+
+// The editor's older `document` node — its `title`, `coverImg` and `src` (or
+// asset identifier) — read into the same shape a markdown document has.
+function documentFromEditorNode(itemAttrs) {
+    const {
+        href,
+        downloadUrl,
+        title = "",
+        alt = "",
+        coverImg,
+        author,
+        description,
+        fileType,
+    } = parseDocumentBlock(itemAttrs || {});
+    return {
+        url: href || downloadUrl || "",
+        alt: alt || title,
+        caption: title,
+        role: "pdf",
+        ...(coverImg && { preview: coverImg }),
+        ...(author && { author }),
+        ...(description && { description }),
+        ...(fileType && { fileType }),
+    };
+}
+
 function parseDocumentBlock(itemAttrs) {
     const { src, info = {}, coverImg = null, ...others } = itemAttrs;