@uniweb/semantic-parser 1.12.0 → 1.12.2

package/package.json

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

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
     }
@@ -161,7 +161,7 @@ function createSequenceElement(node, options = {}) {
             };
 
         case "codeBlock": {
-            const codeText = getTextContent(content, options);
+            const codeText = codeTextOf(content);
             // Tagged code blocks are semantically data blocks, not code — the
             // tag is what routes them to `data[tag]`, so the routing holds even
             // though the payload here is raw text.
@@ -374,22 +374,43 @@ function sameLink(a, b) {
 /**
  * Wrap already-styled inline content in an anchor.
  */
+/**
+ * A code block's code, as written — the characters a reader sees, not HTML.
+ *
+ * Every consumer draws it as text: kit's `Code` (and the highlighter, which
+ * escapes as it colors), press's `CodeBlock`, a foundation's `{snippet.code}`.
+ * ⛔ Until 2026-10-19 it went through `getTextContent`, which escapes text for
+ * the HTML strings a paragraph carries, so a `<` arrived as `&lt;`, was escaped
+ * again where it was drawn, and a page showed `&lt;p&gt;` for `<p>`.
+ */
+function codeTextOf(content) {
+    return (content || [])
+        .map((node) => (node?.type === "text" ? node.text || "" : node?.type === "hardBreak" ? "\n" : ""))
+        .join("");
+}
+
 function wrapLink(inner, linkMark) {
-    return anchor(linkMark.attrs.href, linkMark.attrs.target, inner);
+    return anchor(linkMark.attrs.href, linkMark.attrs.target, inner, linkMark.attrs.role);
 }
 
 /**
  * An anchor around already-escaped inner HTML. A link whose URL may not be
  * followed (`javascript:`, `data:`, any scheme `isSafeLink` refuses) is not
  * drawn as a link: its label stays, as text.
+ *
+ * Its `role` — `button` for a `[Go](/x){button}`, or an authored hint such as
+ * `nav` — rides as `data-role`, a style name or nothing, so a stylesheet can
+ * tell a button from a link. ⛔ Until 2026-10-19 the role was dropped here, and
+ * a button reached the page as a plain link.
  */
-function anchor(href, target, inner) {
+function anchor(href, target, inner, role) {
     if (typeof href !== "string" || !isSafeLink(href)) return inner;
     const t = isLinkTarget(target) ? target : "_self";
     const extension = href.split(".").pop()?.toLowerCase();
     const isFileLink = FILE_LINK_EXTENSIONS.includes(extension);
+    const roleAttr = isStyleName(role) ? ` data-role="${escapeAttr(role)}"` : "";
 
-    return `<a href="${escapeAttr(href)}" target="${t}"${isFileLink ? " download" : ""}>${inner}</a>`;
+    return `<a href="${escapeAttr(href)}" target="${t}"${isFileLink ? " download" : ""}${roleAttr}>${inner}</a>`;
 }
 
 function getTextContent(content, options = {}) {
@@ -453,8 +474,8 @@ function renderInlineNode(curr, iconOrdinals, pictureOrdinals) {
             if (type === "text") {
                 let styledText = escapeText(text || "");
 
-                // Apply marks in order: span, code, bold, italic — the link is
-                // applied per group by getTextContent. This ensures proper nesting.
+                // Apply marks in order: span, code, bold, italic, strike — the link
+                // is applied per group by getTextContent. This ensures proper nesting.
                 //
                 // ⛔ Until 2026-10-18 the editor's `textStyle` (a theme color) and
                 // `highlight` marks were applied first. The editor saves both as
@@ -513,6 +534,12 @@ function renderInlineNode(curr, iconOrdinals, pictureOrdinals) {
                     styledText = `<em>${styledText}</em>`;
                 }
 
+                // strike — `~~text~~`. ⛔ Until 2026-10-19 nothing applied the
+                // mark, so struck text reached the page as ordinary text.
+                if (marks.some((mark) => mark.type === "strike")) {
+                    styledText = `<s>${styledText}</s>`;
+                }
+
                 // The link mark is deliberately NOT applied here — it is the
                 // outermost wrapper and may span several nodes, so
                 // getTextContent applies it once per group.
@@ -585,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",
@@ -624,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 };
         }
     }
 
@@ -1018,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 || [];
@@ -1043,18 +1082,54 @@ function isOnlyLinks(item) {
 
     if (!allLinks) return false;
 
-    // Extract links with all their attributes
-    // Icons in this paragraph go to body.icons separately (no association)
-    return textContent.map((c) => {
-        const linkMark = linkMarkOf(c.marks);
-        return {
+    // One link per anchor, as `getTextContent` draws them: consecutive runs that
+    // carry the same link are ONE link whose label has several runs
+    // (`[**Go** now](/go)`), and anything between two links — the space a line
+    // 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".
+    const groups = [];
+    let current = null;
+    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 || "", 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: {
-                ...linkMark?.attrs,  // Preserve all link attributes (role, target, etc.)
-                label: c.text || "",
+                ...mark?.attrs,
+                label,
+                iconBefore: icons.filter(({ i }) => i < first).pop()?.attrs || null,
+                iconAfter: icons.find(({ i }) => i > last)?.attrs || null,
+                children: processInlineElements(content, options),
             },
-        };
-    });
+        }];
+    }
+
+    // Several links. An icon among them belongs to no one link, and is not carried.
+    return groups.map(({ mark, label }) => ({
+        type: "link",
+        attrs: {
+            ...mark?.attrs,  // Preserve all link attributes (role, target, etc.)
+            label,
+        },
+    }));
 }
 
 // method to check if given item has multiple content parts and each of them has the same link attrs with different inline style (plain, em, strong, u)
@@ -1085,7 +1160,7 @@ function isStyledLink(item, options = {}) {
     )
         return false;
 
-    const { href, target } = firstLinkMark.attrs;
+    const { href, target, role } = firstLinkMark.attrs;
 
     const cleanedContent = content.map((c) => {
         // remove link marks from content items
@@ -1104,7 +1179,7 @@ function isStyledLink(item, options = {}) {
     return {
         type: "paragraph",
         children: processInlineElements(item.content, options),
-        text: anchor(href, target, textContent),
+        text: anchor(href, target, textContent, role),
         attrs: item.attrs,
     };
 }