@uniweb/semantic-parser 1.12.0 → 1.12.1

package/package.json

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

package/src/processors/sequence.js

@@ -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.
@@ -1043,18 +1070,35 @@ function isOnlyLinks(item) {
 
     if (!allLinks) return false;
 
-    // Extract links with all their attributes
+    // 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".
     // Icons in this paragraph go to body.icons separately (no association)
-    return textContent.map((c) => {
-        const linkMark = linkMarkOf(c.marks);
-        return {
-            type: "link",
-            attrs: {
-                ...linkMark?.attrs,  // Preserve all link attributes (role, target, etc.)
-                label: c.text || "",
-            },
-        };
-    });
+    const groups = [];
+    let current = null;
+    for (const c of content) {
+        const mark = c.type === "text" ? linkMarkOf(c.marks) : null;
+        if (mark && current && sameLink(current.mark, mark)) {
+            current.label += c.text || "";
+        } else if (mark) {
+            current = { mark, label: c.text || "" };
+            groups.push(current);
+        } else {
+            current = null;
+        }
+    }
+
+    // Extract links with all their attributes
+    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 +1129,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 +1148,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,
     };
 }