@vicacha-devs/astro-tiptap-blocks 1.2.0 → 1.2.1

package/dist/lib/markdown-parser/markdown-parser.js

@@ -1,65 +1,18 @@
 import { parseTiptapHtml } from "../html-parser";
-import { sanitizeTiptapIframeUrl, sanitizeTiptapUrl } from "../sanitize";
+import { sanitizeTiptapUrl } from "../sanitize";
+import { isLikelyMarkdown, parseMarkdownInline, parseMediaBlock, parseQuoteChunk, } from "./markdown-inline";
+export { isLikelyMarkdown, parseMarkdownInline };
 const TIPTAP_META_COMMENT_RE = /\n?<!--\s*tiptap-node:([\s\S]*?)\s*-->$/;
-export const parseMarkdownInline = (text) => {
-    if (!text)
-        return [];
-    const nodes = [];
-    const tokenRe = /(\$(?!\$)([^$\n]+)\$|!\[([^\]]*)\]\(([^)\s]+)(?:\s+"([^"]*)")?\)|\[([^\]]+)\]\(([^)\s]+)(?:\s+"([^"]*)")?\)|`([^`]+)`|\*\*([^*]+)\*\*|==([^=]+)==|~~([^~]+)~~|\*([^*]+)\*|<([a-zA-Z0-9-]+)(?:\s[^>]*)?>[\s\S]*?<\/\14>)/g;
-    let lastIdx = 0;
-    let match;
-    while ((match = tokenRe.exec(text)) !== null) {
-        if (match.index > lastIdx)
-            nodes.push({ type: "text", text: text.slice(lastIdx, match.index) });
-        if (match[2] !== undefined) {
-            nodes.push({ type: "mathematics", attrs: { latex: match[2].trim(), displayMode: "inline" } });
-        }
-        else if (match[6] !== undefined && match[7] !== undefined) {
-            const label = match[6];
-            const rawHref = match[7];
-            if (/^(?:tiptap|internal|cms|doc):\/\//.test(rawHref)) {
-                const parts = rawHref.replace(/^[a-z]+:\/\//i, "").split("/");
-                nodes.push({
-                    type: "linker",
-                    attrs: {
-                        collectionName: parts[0] || null,
-                        documentId: parts[1] || null,
-                        label,
-                        href: rawHref,
-                    },
-                });
-            }
-            else {
-                nodes.push({
-                    type: "text",
-                    text: label,
-                    marks: [
-                        { type: "link", attrs: { href: sanitizeTiptapUrl(rawHref), title: match[8] || null } },
-                    ],
-                });
-            }
-        }
-        else if (match[9] !== undefined)
-            nodes.push({ type: "text", text: match[9], marks: [{ type: "code" }] });
-        else if (match[10] !== undefined)
-            nodes.push({ type: "text", text: match[10], marks: [{ type: "bold" }] });
-        else if (match[11] !== undefined)
-            nodes.push({ type: "text", text: match[11], marks: [{ type: "highlight" }] });
-        else if (match[12] !== undefined)
-            nodes.push({ type: "text", text: match[12], marks: [{ type: "strike" }] });
-        else if (match[13] !== undefined)
-            nodes.push({ type: "text", text: match[13], marks: [{ type: "italic" }] });
-        else if (match[14] !== undefined) {
-            const first = parseTiptapHtml(`<p>${match[0]}</p>`).content[0];
-            if (first && "content" in first && Array.isArray(first.content))
-                nodes.push(...first.content);
-        }
-        lastIdx = tokenRe.lastIndex;
-    }
-    if (lastIdx < text.length)
-        nodes.push({ type: "text", text: text.slice(lastIdx) });
-    return nodes;
-};
+const parseTableCells = (rowStr, isHeader) => rowStr
+    .trim()
+    .replace(/^\||\|$/g, "")
+    .split(/(?<!\\)\|/)
+    .map((c) => ({
+    type: isHeader ? "tableHeader" : "tableCell",
+    content: [
+        { type: "paragraph", content: parseMarkdownInline(c.replace(/\\\|/g, "|").trim()) },
+    ],
+}));
 const parseMarkdownChunk = (rawChunk) => {
     const metaMatch = TIPTAP_META_COMMENT_RE.exec(rawChunk);
     if (metaMatch) {
@@ -69,7 +22,7 @@ const parseMarkdownChunk = (rawChunk) => {
                 return [parsed];
         }
         catch {
-            // Fallback to markdown parsing
+            /* fallback to markdown parsing */
         }
     }
     const chunk = rawChunk.replace(TIPTAP_META_COMMENT_RE, "").trim();
@@ -112,35 +65,7 @@ const parseMarkdownChunk = (rawChunk) => {
     }
     const mediaMatch = /^\[(?:(Video|Audio|Attachment|Embed):\s*([^\]]*))\]\(([^)\s]+)\)$/.exec(chunk);
     if (mediaMatch) {
-        const kind = mediaMatch[1].toLowerCase();
-        const label = mediaMatch[2].trim();
-        const rawUrl = mediaMatch[3];
-        if (kind === "video") {
-            const src = sanitizeTiptapUrl(rawUrl);
-            const isEmbed = /youtube\.com|youtu\.be|vimeo\.com/i.test(src);
-            return src === "#"
-                ? []
-                : [
-                    {
-                        type: "video",
-                        attrs: { src, title: label, caption: label, embedType: isEmbed ? "embed" : "file" },
-                    },
-                ];
-        }
-        if (kind === "audio") {
-            const src = sanitizeTiptapUrl(rawUrl);
-            return src === "#" ? [] : [{ type: "audio", attrs: { src, title: label, caption: label } }];
-        }
-        if (kind === "attachment") {
-            const href = sanitizeTiptapUrl(rawUrl);
-            return href === "#"
-                ? []
-                : [{ type: "attachment", attrs: { href, filename: label, title: label } }];
-        }
-        if (kind === "embed") {
-            const src = sanitizeTiptapIframeUrl(rawUrl);
-            return src === "#" ? [] : [{ type: "iframe", attrs: { src, title: label } }];
-        }
+        return parseMediaBlock(mediaMatch[1].toLowerCase(), mediaMatch[2].trim(), mediaMatch[3]);
     }
     const imgMatch = /^!\[([^\]]*)\]\(([^)\s]+)(?:\s+"([^"]*)")?\)$/.exec(chunk);
     if (imgMatch) {
@@ -150,41 +75,7 @@ const parseMarkdownChunk = (rawChunk) => {
             : [{ type: "image", attrs: { src, alt: imgMatch[1] || "", title: imgMatch[3] || null } }];
     }
     if (chunk.startsWith(">")) {
-        const stripped = chunk
-            .split("\n")
-            .map((l) => l.replace(/^>\s?/, ""))
-            .join("\n")
-            .trim();
-        if (stripped.startsWith("**Lead:**")) {
-            return [
-                {
-                    type: "leadParagraph",
-                    content: parseMarkdownInline(stripped.replace(/^\*\*Lead:\*\*\s*/, "")),
-                },
-            ];
-        }
-        const calloutMatch = /^\[!(INFO|SUCCESS|WARNING|DANGER|NEUTRAL|TIP)\](?:\s+([^\n]*))?\n?([\s\S]*)$/i.exec(stripped);
-        if (calloutMatch) {
-            const variant = calloutMatch[1].toLowerCase();
-            return [
-                {
-                    type: "informationPane",
-                    attrs: { variant, title: calloutMatch[2]?.trim() || null },
-                    content: parseTiptapMarkdown(calloutMatch[3] || "").content,
-                },
-            ];
-        }
-        const convMatch = /^\*\*Conversation History\*\*(?:\s+\*\(([^)]+)\)\*)?\n?([\s\S]*)$/i.exec(stripped);
-        if (convMatch) {
-            return [
-                {
-                    type: "conversationHistory",
-                    attrs: { author: convMatch[1] || null },
-                    content: parseTiptapMarkdown(convMatch[2] || "").content,
-                },
-            ];
-        }
-        return [{ type: "blockquote", content: parseTiptapMarkdown(stripped).content }];
+        return parseQuoteChunk(chunk, (md) => parseTiptapMarkdown(md).content);
     }
     const lines = chunk.split("\n");
     if (lines.every((l) => /^[-*]\s+\[([ xX])\]\s+/.test(l.trim()))) {
@@ -216,9 +107,11 @@ const parseMarkdownChunk = (rawChunk) => {
         ];
     }
     if (lines.every((l) => /^\d+\.\s+/.test(l.trim()))) {
+        const firstStart = Number(/^(\d+)\.\s+/.exec(lines[0].trim())?.[1] ?? 1);
         return [
             {
                 type: "orderedList",
+                ...(firstStart > 1 ? { attrs: { start: firstStart } } : {}),
                 content: lines.map((l) => ({
                     type: "listItem",
                     content: [
@@ -229,20 +122,12 @@ const parseMarkdownChunk = (rawChunk) => {
         ];
     }
     if (lines.length >= 2 && lines[0].includes("|") && /^\s*\|?[\s:-]+\|/.test(lines[1])) {
-        const parseCells = (rowStr, isHeader) => rowStr
-            .trim()
-            .replace(/^\||\|$/g, "")
-            .split("|")
-            .map((c) => ({
-            type: isHeader ? "tableHeader" : "tableCell",
-            content: [{ type: "paragraph", content: parseMarkdownInline(c.trim()) }],
-        }));
         const rows = [
-            { type: "tableRow", content: parseCells(lines[0], true) },
+            { type: "tableRow", content: parseTableCells(lines[0], true) },
             ...lines
                 .slice(2)
                 .filter((l) => l.includes("|"))
-                .map((l) => ({ type: "tableRow", content: parseCells(l, false) })),
+                .map((l) => ({ type: "tableRow", content: parseTableCells(l, false) })),
         ];
         return [{ type: "table", content: rows }];
     }
@@ -250,7 +135,6 @@ const parseMarkdownChunk = (rawChunk) => {
         return parseTiptapHtml(chunk).content;
     return [{ type: "paragraph", content: parseMarkdownInline(chunk) }];
 };
-export const isLikelyMarkdown = (text) => /(?:^|\n)(?:#{1,6}\s|>\s|[-*]\s+\[[ xX]\]\s|[-*]\s+\S|\d+\.\s+\S|```|\$\$|<!--\s*(?:tiptap-node:|pagebreak|toc)|\[(?:Video|Audio|Attachment|Embed):|!\[[^\]]*\]\([^)]+\)|\|.+\|\n\|[\s:-]+\|)/.test(text) || /(\*\*[^*]+\*\*|==[^=]+==|~~[^~]+~~|\[[^\]]+\]\([^)]+\)|\$(?!\$)[^$\n]+\$)/.test(text);
 export const parseTiptapMarkdown = (markdown) => {
     const chunks = markdown.trim().split(/\n{2,}(?!(?:[^`]*```[^`]*```)*[^`]*```)/);
     const content = [];

package/dist/lib/parser/index.d.ts

@@ -1 +1,2 @@
 export * from "./parser";
+export { extractDetailsParts } from "./parser-inline";

package/dist/lib/parser/index.js

@@ -1 +1,2 @@
 export * from "./parser";
+export { extractDetailsParts } from "./parser-inline";

package/dist/lib/parser/parser-inline.d.ts

@@ -0,0 +1,14 @@
+import type { TiptapBlockNode, TiptapDetailsNode, TiptapInlineNode, TiptapMark, TiptapParserOptions } from "../../types";
+export declare const extractInlineText: (nodes?: TiptapInlineNode[]) => string;
+export declare const extractDetailsParts: (content?: TiptapDetailsNode["content"]) => {
+    summary: TiptapInlineNode[];
+    body: TiptapBlockNode[];
+};
+export declare const sanitizeMarks: (marks?: TiptapMark[], options?: TiptapParserOptions) => TiptapMark[] | undefined;
+export declare const sanitizeInlineNodes: (nodes?: TiptapInlineNode[], options?: TiptapParserOptions) => TiptapInlineNode[];
+export declare const allocateHeadingId: (explicitId: string | null | undefined, rawText: string, usedIds: Map<string, number>) => string | null;
+export declare const sanitizeCustomBlock: (custom: {
+    type?: string;
+    attrs?: Record<string, unknown>;
+    content?: TiptapBlockNode[];
+}, options: TiptapParserOptions | undefined, recurse: (children?: TiptapBlockNode[]) => TiptapBlockNode[]) => TiptapBlockNode | null;

package/dist/lib/parser/parser-inline.js

@@ -0,0 +1,122 @@
+import { resolveInternalLinkHref } from "../relations/relations-uri";
+import { resolveTiptapMediaUrl, sanitizeCssColor, sanitizeTextStyleAttrs, sanitizeTiptapSrcset, slugifyHeadingText, } from "../sanitize";
+const BLOCKED_CUSTOM_ATTR_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+const URL_ATTR_KEY_REGEX = /^(?:src|href|url|action|formaction)$|(?:Url|Href|Src|Uri|_url|_href|_src|-url|-href|-src)$/;
+export const extractInlineText = (nodes) => (nodes ?? [])
+    .map((n) => (n.type === "text" ? n.text : n.type === "linker" ? n.attrs.label || "" : ""))
+    .join("");
+export const extractDetailsParts = (content = []) => {
+    const summaryNode = content.find((child) => child.type === "detailsSummary");
+    const detailsContentNode = content.find((child) => child.type === "detailsContent");
+    const body = detailsContentNode
+        ? detailsContentNode.content || []
+        : content.filter((child) => child.type !== "detailsSummary" && child.type !== "detailsContent");
+    return { summary: summaryNode?.content || [], body };
+};
+export const sanitizeMarks = (marks, options) => {
+    if (!Array.isArray(marks) || marks.length === 0)
+        return undefined;
+    const result = [];
+    for (const mark of marks) {
+        if (!mark || typeof mark !== "object" || !("type" in mark))
+            continue;
+        if (mark.type === "link") {
+            result.push({
+                ...mark,
+                attrs: {
+                    ...mark.attrs,
+                    href: resolveInternalLinkHref({ href: mark.attrs?.href }, options?.resolveInternalLink),
+                },
+            });
+        }
+        else if (mark.type === "highlight") {
+            const color = sanitizeCssColor(mark.attrs?.color);
+            result.push({ type: "highlight", ...(color ? { attrs: { color } } : {}) });
+        }
+        else if (mark.type === "textStyle") {
+            const safeAttrs = sanitizeTextStyleAttrs(mark.attrs);
+            if (safeAttrs)
+                result.push({ type: "textStyle", attrs: safeAttrs });
+        }
+        else {
+            result.push(mark);
+        }
+    }
+    return result.length > 0 ? result : undefined;
+};
+export const sanitizeInlineNodes = (nodes, options) => {
+    if (!Array.isArray(nodes))
+        return [];
+    const result = [];
+    for (const node of nodes) {
+        if (!node || typeof node !== "object" || !("type" in node))
+            continue;
+        if (node.type === "text") {
+            const marks = sanitizeMarks(node.marks, options);
+            result.push({
+                type: "text",
+                text: typeof node.text === "string" ? node.text : "",
+                ...(marks ? { marks } : {}),
+            });
+        }
+        else if (node.type === "hardBreak") {
+            result.push({ type: "hardBreak" });
+        }
+        else if (node.type === "linker") {
+            const href = resolveInternalLinkHref(node.attrs || {}, options?.resolveInternalLink);
+            result.push({ ...node, attrs: { ...node.attrs, href } });
+        }
+        else if (node.type === "mathematics") {
+            result.push({
+                type: "mathematics",
+                attrs: {
+                    latex: String(node.attrs?.latex ?? ""),
+                    displayMode: node.attrs?.displayMode ?? "inline",
+                },
+            });
+        }
+    }
+    return result;
+};
+export const allocateHeadingId = (explicitId, rawText, usedIds) => {
+    if (explicitId && explicitId.trim()) {
+        const clean = explicitId.trim();
+        usedIds.set(clean, (usedIds.get(clean) ?? 0) + 1);
+        return clean;
+    }
+    if (!rawText.trim())
+        return null;
+    const base = slugifyHeadingText(rawText);
+    const count = (usedIds.get(base) ?? 0) + 1;
+    usedIds.set(base, count);
+    return count === 1 ? base : `${base}-${count}`;
+};
+export const sanitizeCustomBlock = (custom, options, recurse) => {
+    if (typeof custom.type !== "string" || !custom.type.trim())
+        return null;
+    const safeAttrs = {};
+    for (const [k, v] of Object.entries(custom.attrs ?? {})) {
+        if (BLOCKED_CUSTOM_ATTR_KEYS.has(k) || /^on[a-z]/i.test(k))
+            continue;
+        if (typeof v === "string" && /srcset$/i.test(k)) {
+            const safeSrcset = sanitizeTiptapSrcset(v, options);
+            if (!safeSrcset)
+                return null;
+            safeAttrs[k] = safeSrcset;
+        }
+        else if (typeof v === "string" && URL_ATTR_KEY_REGEX.test(k)) {
+            const resolved = resolveTiptapMediaUrl(v, options);
+            if (resolved === "#")
+                return null;
+            safeAttrs[k] = resolved;
+        }
+        else {
+            safeAttrs[k] = v;
+        }
+    }
+    return {
+        type: custom.type,
+        ...(custom.attrs ? { attrs: safeAttrs } : {}),
+        ...(Array.isArray(custom.content) ? { content: recurse(custom.content) } : {}),
+    };
+};

package/dist/lib/parser/parser-sanitize.d.ts

@@ -0,0 +1,2 @@
+import type { TiptapBlockNode, TiptapParserOptions } from "../../types";
+export declare const sanitizeBlockNodes: (nodes?: TiptapBlockNode[], options?: TiptapParserOptions, usedHeadingIds?: Map<string, number>) => TiptapBlockNode[];

package/dist/lib/parser/parser-sanitize.js

@@ -0,0 +1,149 @@
+import { resolveTiptapMediaUrl, sanitizeCssColor, sanitizeTiptapIframeUrl, sanitizeTiptapSrcset, } from "../sanitize";
+import { allocateHeadingId, extractInlineText, sanitizeCustomBlock, sanitizeInlineNodes, } from "./parser-inline";
+export const sanitizeBlockNodes = (nodes, options, usedHeadingIds = new Map()) => {
+    if (!Array.isArray(nodes))
+        return [];
+    const recurse = (children) => sanitizeBlockNodes(children, options, usedHeadingIds);
+    const result = [];
+    for (const node of nodes) {
+        if (!node || typeof node !== "object" || !("type" in node))
+            continue;
+        switch (node.type) {
+            case "heading": {
+                const content = sanitizeInlineNodes(node.content, options);
+                const level = (node.attrs?.level ?? 2);
+                const id = allocateHeadingId(node.attrs?.id, extractInlineText(content), usedHeadingIds);
+                result.push({ ...node, attrs: { ...node.attrs, level, ...(id ? { id } : {}) }, content });
+                break;
+            }
+            case "paragraph":
+            case "leadParagraph":
+                result.push({ ...node, content: sanitizeInlineNodes(node.content, options) });
+                break;
+            case "blockquote":
+            case "informationPane":
+            case "conversationHistory":
+                result.push({ ...node, content: recurse(node.content) });
+                break;
+            case "details":
+                result.push({
+                    ...node,
+                    content: (node.content ?? [])
+                        .map((child) => child.type === "detailsSummary"
+                        ? {
+                            type: "detailsSummary",
+                            content: sanitizeInlineNodes(child.content, options),
+                        }
+                        : child.type === "detailsContent"
+                            ? { type: "detailsContent", content: recurse(child.content) }
+                            : recurse([child])[0])
+                        .filter(Boolean),
+                });
+                break;
+            case "layoutContainer":
+                result.push({
+                    ...node,
+                    content: (node.content ?? []).map((col) => ({
+                        type: "layoutColumn",
+                        content: recurse(col.content),
+                    })),
+                });
+                break;
+            case "bulletList":
+            case "orderedList":
+                result.push({
+                    ...node,
+                    content: (node.content ?? []).map((item) => ({
+                        type: "listItem",
+                        content: recurse(item.content),
+                    })),
+                });
+                break;
+            case "taskList":
+                result.push({
+                    ...node,
+                    content: (node.content ?? []).map((item) => ({
+                        type: "taskItem",
+                        attrs: { checked: Boolean(item.attrs?.checked) },
+                        content: recurse(item.content),
+                    })),
+                });
+                break;
+            case "codeBlock":
+                result.push({
+                    ...node,
+                    content: sanitizeInlineNodes(node.content, options).filter((n) => n.type === "text"),
+                });
+                break;
+            case "image": {
+                const safeSrc = resolveTiptapMediaUrl(node.attrs?.src, options);
+                if (safeSrc !== "#") {
+                    const safeSrcset = sanitizeTiptapSrcset(node.attrs?.srcset, options);
+                    result.push({
+                        ...node,
+                        attrs: { ...node.attrs, src: safeSrc, ...(safeSrcset ? { srcset: safeSrcset } : {}) },
+                    });
+                }
+                break;
+            }
+            case "video":
+            case "audio": {
+                const safeSrc = resolveTiptapMediaUrl(node.attrs?.src, options);
+                if (safeSrc !== "#")
+                    result.push({ ...node, attrs: { ...node.attrs, src: safeSrc } });
+                break;
+            }
+            case "attachment": {
+                const safeHref = resolveTiptapMediaUrl(node.attrs?.href, options);
+                if (safeHref !== "#")
+                    result.push({ ...node, attrs: { ...node.attrs, href: safeHref } });
+                break;
+            }
+            case "iframe": {
+                const safeSrc = sanitizeTiptapIframeUrl(node.attrs?.src, options?.allowedIframeDomains);
+                if (safeSrc !== "#")
+                    result.push({ ...node, attrs: { ...node.attrs, src: safeSrc } });
+                break;
+            }
+            case "mathematics":
+                result.push({
+                    type: "mathematics",
+                    attrs: {
+                        latex: String(node.attrs?.latex ?? ""),
+                        displayMode: node.attrs?.displayMode ?? "block",
+                    },
+                });
+                break;
+            case "tableOfContents":
+                result.push({ ...node });
+                break;
+            case "pageBreak":
+            case "horizontalRule":
+                result.push({ type: node.type });
+                break;
+            case "table":
+                result.push({
+                    ...node,
+                    content: (node.content ?? []).map((row) => ({
+                        type: "tableRow",
+                        content: (row.content ?? []).map((cell) => ({
+                            ...cell,
+                            attrs: {
+                                ...cell.attrs,
+                                backgroundColor: sanitizeCssColor(cell.attrs?.backgroundColor),
+                            },
+                            content: recurse(cell.content),
+                        })),
+                    })),
+                });
+                break;
+            default: {
+                const safeCustom = sanitizeCustomBlock(node, options, recurse);
+                if (safeCustom)
+                    result.push(safeCustom);
+                break;
+            }
+        }
+    }
+    return result;
+};