@uniweb/semantic-parser 1.12.1 → 1.13.0

package/README.md

@@ -298,6 +298,13 @@ A renderer that reads `text` as HTML and does not know a marker draws
 nothing for it, as for any empty element it does not know. kit's `<Render>`
 draws an icon with `<Icon>` and a picture with `<Image>`.
 
+An icon **before any text** is the element's own icon, not part of its prose:
+`![](lu-cloud)` on a line of its own, `- ![](lu-globe) Web App`, or
+`## ![](lu-zap) Fast`. The flat fields (`title`, `paragraphs`, a list item's)
+leave out its marker, since a component draws that icon from `icons`, beside
+the words. So a line holding only icons adds no paragraph. The `sequence`
+keeps every marker, for a renderer that draws each icon where it sat.
+
 ## Use Cases
 
 - **Component-based websites**: Extract structured data for React/Vue components

package/package.json

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

package/src/processors/groups.js

@@ -286,6 +286,29 @@ function readStack(sequence, startIdx, options = {}) {
     return { pre, title, sub, length: i - startIdx };
 }
 
+/**
+ * An element's text as a flat field holds it, without the markers of the icons before its words.
+ *
+ * ⭐ An icon before any text is the element's own icon, not part of its prose: `![](lu-cloud)` on
+ * a line of its own, `- ![](lu-globe) Web App`, `## ![](lu-zap) Fast`. The flat fields (`title`,
+ * `paragraphs`, a list item's) hold the text a component draws beside that icon, which it finds
+ * in `icons`. So the markers before the words go, and a line holding only icons leaves no
+ * paragraph. An icon inside the prose keeps its marker, with its ordinal unchanged, since `icons`
+ * still lists the leading ones. The `sequence` keeps every marker: kit's `Render` draws each icon
+ * where it sat [Diego, 2026-10-24].
+ *
+ * ⛔ From 2026-08-12 to 2026-10-24 the flat fields kept the leading markers. An icon-only line
+ * became a paragraph of nothing but `<uniweb-icon data-index="0"></uniweb-icon>`, which moved
+ * `paragraphs[0]` off the text, and a component drawing a paragraph as text showed the markup.
+ *
+ * @param {*} text
+ * @returns {*} the text without its leading icon markers; anything that is no string, as it came
+ */
+function flatText(text) {
+    if (typeof text !== "string") return text;
+    return text.replace(/^(?:\s*<uniweb-icon data-index="\d+"><\/uniweb-icon>)+\s*/, "");
+}
+
 /** Collapse a slot's texts: none → '', one → string, several → array. */
 function flattenSlot(texts) {
     if (texts.length === 0) return "";
@@ -346,9 +369,9 @@ function processGroupContent(elements, options = {}) {
     let start = 0;
     if (elements[0]?.type === "heading") {
         const stack = readStack(elements, 0, options);
-        header.pretitle = flattenSlot(stack.pre.map((el) => el.text));
-        header.title = flattenSlot(stack.title.map((el) => el.text));
-        header.subtitle = flattenSlot(stack.sub.map((el) => el.text));
+        header.pretitle = flattenSlot(stack.pre.map((el) => flatText(el.text)));
+        header.title = flattenSlot(stack.title.map((el) => flatText(el.text)));
+        header.subtitle = flattenSlot(stack.sub.map((el) => flatText(el.text)));
         metadata.level = stack.title[0]?.level ?? null;
         for (const el of [...stack.pre, ...stack.title, ...stack.sub]) {
             if (el.children && Array.isArray(el.children))
@@ -366,7 +389,7 @@ function processGroupContent(elements, options = {}) {
             // array — section content is split into groups before this runs.
             if (element.children && Array.isArray(element.children))
                 processInlineElements(element.children, body);
-            body.headings.push(element.text);
+            body.headings.push(flatText(element.text));
         } else if (element.type === "list") {
             const listItems = element.children;
 
@@ -383,7 +406,10 @@ function processGroupContent(elements, options = {}) {
                     if (element.children && Array.isArray(element.children))
                         processInlineElements(element.children, body);
 
-                    if (element.text) body.paragraphs.push(element.text);
+                    {
+                        const flat = flatText(element.text);
+                        if (flat) body.paragraphs.push(flat);
+                    }
                     break;
 
                 case "image":

package/src/processors/sequence.js

@@ -79,7 +79,7 @@ function createSequenceElement(node, options = {}) {
     }
 
     // Check for paragraph containing only multiple links (no other text)
-    const multipleLinks = isOnlyLinks(node);
+    const multipleLinks = isOnlyLinks(node, options);
     if (multipleLinks && multipleLinks.every((l) => isSafeLink(l.attrs?.href))) {
         return multipleLinks; // Returns array of link elements
     }
@@ -612,8 +612,20 @@ function processInlineElements(content, options = {}) {
     if (!content) return [];
 
     const items = [];
+    // The link the previous run belongs to, while the runs continue it: a label
+    // in several styles (`[the *full* guide](/guide)`) is one link, as its anchor
+    // is. ⛔ Until 2026-10-19 each run was a link here, so `content.links` held
+    // "the ", "full" and " guide".
+    let open = null;
 
     for (const item of content) {
+        const runLink = item.type === "text" ? linkMarkOf(item.marks) : null;
+        if (runLink && open && sameLink(open.mark, runLink)) {
+            open.link.attrs.label += item.text || "";
+            continue;
+        }
+        open = null;
+
         if (isIconNode(item)) {
             items.push({
                 type: "icon",
@@ -651,18 +663,17 @@ function processInlineElements(content, options = {}) {
                 refId: item.attrs?.refId,
                 embedKind: item.attrs?.embedKind || "visual",
             });
-        } else if (item.type === "text" && item.marks) {
+        } else if (runLink && isSafeLink(runLink.attrs?.href)) {
             // Extract links from text nodes with link marks
-            const linkMark = linkMarkOf(item.marks);
-            if (linkMark && isSafeLink(linkMark.attrs?.href)) {
-                items.push({
-                    type: "link",
-                    attrs: {
-                        ...linkMark.attrs,  // Preserve all link attributes (role, target, etc.)
-                        label: item.text || "",
-                    },
-                });
-            }
+            const link = {
+                type: "link",
+                attrs: {
+                    ...runLink.attrs,  // Preserve all link attributes (role, target, etc.)
+                    label: item.text || "",
+                },
+            };
+            items.push(link);
+            open = { mark: runLink, link };
         }
     }
 
@@ -1045,9 +1056,10 @@ function isLink(item, options = {}) {
  * Markdown treats these as a single paragraph, but semantically they're separate links.
  *
  * @param {Object} item - Sequence item (paragraph)
+ * @param {Object} [options] - Parse options, for the one-link case's `children`
  * @returns {Array|false} Array of link objects or false
  */
-function isOnlyLinks(item) {
+function isOnlyLinks(item, options = {}) {
     if (item.type !== "paragraph") return false;
 
     const content = item?.content || [];
@@ -1076,22 +1088,41 @@ function isOnlyLinks(item) {
     // break becomes, an icon — keeps them apart. ⛔ Until 2026-10-19 every run
     // was a link of its own, so a button labelled in two styles became two
     // buttons, "Go" and " now".
-    // Icons in this paragraph go to body.icons separately (no association)
     const groups = [];
     let current = null;
-    for (const c of content) {
+    content.forEach((c, i) => {
         const mark = c.type === "text" ? linkMarkOf(c.marks) : null;
         if (mark && current && sameLink(current.mark, mark)) {
             current.label += c.text || "";
+            current.last = i;
         } else if (mark) {
-            current = { mark, label: c.text || "" };
+            current = { mark, label: c.text || "", first: i, last: i };
             groups.push(current);
         } else {
             current = null;
         }
+    });
+
+    // One link in several runs is a paragraph that is just a link, and takes the
+    // shape `isLink` gives one — its icons, the last before it and the first
+    // after, and its inline elements. ⛔ Until 2026-10-19 its icons were dropped:
+    // `![](lu-star) [**Go** now](/go){button}` lost the star.
+    if (groups.length === 1) {
+        const [{ mark, label, first, last }] = groups;
+        const icons = content.map((c, i) => (isIconNode(c) ? { i, attrs: parseIcon(c.attrs) } : null)).filter(Boolean);
+        return [{
+            type: "link",
+            attrs: {
+                ...mark?.attrs,
+                label,
+                iconBefore: icons.filter(({ i }) => i < first).pop()?.attrs || null,
+                iconAfter: icons.find(({ i }) => i > last)?.attrs || null,
+                children: processInlineElements(content, options),
+            },
+        }];
     }
 
-    // Extract links with all their attributes
+    // Several links. An icon among them belongs to no one link, and is not carried.
     return groups.map(({ mark, label }) => ({
         type: "link",
         attrs: {