@uniweb/content-reader 1.0.0

package/src/parser/patterns.js

@@ -0,0 +1,46 @@
+/**
+ * @fileoverview Pattern detection for markdown structures
+ */
+
+import { parseInline } from "./inline.js";
+
+/**
+ * Check if tokens represent an eyebrow pattern
+ * @param {Array} tokens - Array of tokens
+ * @param {number} index - Current token index
+ * @returns {boolean}
+ */
+function isEyebrowPattern(tokens, index) {
+  return (
+    tokens[index]?.type === "heading" &&
+    tokens[index]?.depth === 3 &&
+    tokens[index + 1]?.type === "heading" &&
+    tokens[index + 1]?.depth === 1
+  );
+}
+
+/**
+ * Parse eyebrow heading pattern
+ * @param {Array} tokens - Array of tokens
+ * @param {number} index - Current token index
+ * @param {Object} schema - ProseMirror schema
+ * @returns {Array} Array of ProseMirror nodes
+ */
+function parseEyebrowPattern(tokens, index, schema) {
+  return [
+    {
+      type: "eyebrowHeading",
+      content: tokens[index].tokens.flatMap((t) => parseInline(t, schema)),
+    },
+    {
+      type: "heading",
+      attrs: {
+        level: 1,
+        id: null,
+      },
+      content: tokens[index + 1].tokens.flatMap((t) => parseInline(t, schema)),
+    },
+  ];
+}
+
+export { isEyebrowPattern, parseEyebrowPattern };

package/src/parser/tables.js

@@ -0,0 +1,75 @@
+/**
+ * @fileoverview Parse markdown tables
+ */
+
+import { marked } from "marked";
+import { parseInline } from "./inline.js";
+
+/**
+ * Extract alignment from column definition
+ * @param {string} colDef - Column definition from separator row
+ * @returns {string|null} Alignment (left, center, right) or null
+ */
+function getColumnAlignment(colDef) {
+  if (!colDef) return null;
+  const trimmed = colDef.trim();
+  if (trimmed.startsWith(":") && trimmed.endsWith(":")) return "center";
+  if (trimmed.endsWith(":")) return "right";
+  if (trimmed.startsWith(":")) return "left";
+  return null;
+}
+
+/**
+ * Parse table row content
+ * @param {Object} token - Row token
+ * @param {boolean} isHeader - Whether this is a header row
+ * @param {Array} alignments - Column alignments
+ * @param {Object} schema - ProseMirror schema
+ * @returns {Object} Table row node
+ */
+function parseTableRow(row, isHeader, alignments, schema) {
+  return {
+    type: "tableRow",
+    content: row.map((cell, index) => ({
+      type: "tableCell",
+      attrs: {
+        colspan: 1,
+        rowspan: 1,
+        align: alignments[index] || null,
+        header: isHeader,
+      },
+      content: [
+        {
+          type: "paragraph",
+          content: marked.Lexer.lexInline(cell).flatMap((t) =>
+            parseInline(t, schema)
+          ),
+        },
+      ],
+    })),
+  };
+}
+
+/**
+ * Parse table block
+ * @param {Object} token - Table token
+ * @param {Object} schema - ProseMirror schema
+ * @returns {Object} ProseMirror table node
+ */
+function parseTable(token, schema) {
+  // Extract alignments from separator row
+  const alignments = token.align || [];
+
+  // Build rows
+  const headerRow = parseTableRow(token.header, true, alignments, schema);
+  const bodyRows = token.rows.map((row) =>
+    parseTableRow(row, false, alignments, schema)
+  );
+
+  return {
+    type: "table",
+    content: [headerRow, ...bodyRows],
+  };
+}
+
+export { parseTable };

package/src/parser/utils.js

@@ -0,0 +1,24 @@
+/**
+ * @fileoverview Shared utility functions for parsing
+ */
+
+/**
+ * Check if content is empty or whitespace-only
+ * @param {Array} content - Array of inline content nodes
+ * @returns {boolean}
+ */
+function isEmptyContent(content) {
+  if (!content || content.length === 0) return true;
+
+  if (content.length === 1) {
+    const node = content[0];
+    if (node.type === "text") {
+      const text = node.text || "";
+      return text.trim() === "";
+    }
+  }
+
+  return false;
+}
+
+export { isEmptyContent };

package/src/schema/index.js

@@ -0,0 +1,144 @@
+/**
+ * @fileoverview Base schema definition compatible with TipTap v2
+ */
+
+const baseNodes = {
+    doc: {
+        content: "block+",
+    },
+
+    paragraph: {
+        content: "inline*",
+        group: "block",
+    },
+
+    heading: {
+        attrs: {
+            level: { default: 1 },
+            id: { default: null },
+        },
+        content: "inline*",
+        group: "block",
+    },
+
+    eyebrowHeading: {
+        content: "inline*",
+        group: "block",
+    },
+
+    text: {
+        group: "inline",
+    },
+
+    image: {
+        attrs: {
+            src: {},
+            caption: { default: null },
+            alt: { default: null },
+            role: { default: "content" },
+        },
+        // group: "block inline",
+    },
+
+    divider: {
+        attrs: {
+            style: { default: "line" },
+            size: { default: "normal" },
+        },
+        group: "block",
+    },
+
+    // List nodes
+    bulletList: {
+        content: "listItem+",
+        group: "block",
+    },
+
+    orderedList: {
+        attrs: {
+            start: { default: 1 },
+        },
+        content: "listItem+",
+        group: "block",
+    },
+
+    listItem: {
+        content: "paragraph block*",
+        defining: true,
+    },
+
+    // Code blocks
+    codeBlock: {
+        attrs: {
+            language: { default: null },
+            filename: { default: null },
+        },
+        content: "text*",
+        marks: "", // No marks (formatting) allowed inside code blocks
+        group: "block",
+        code: true,
+        defining: true,
+    },
+    blockquote: {
+        content: "inline*",
+        group: "block",
+    },
+    // Table nodes
+    table: {
+        content: "tableRow+",
+        group: "block",
+        tableRole: "table",
+    },
+
+    tableRow: {
+        content: "tableCell+",
+        tableRole: "row",
+    },
+
+    tableCell: {
+        content: "paragraph+",
+        attrs: {
+            colspan: { default: 1 },
+            rowspan: { default: 1 },
+            align: { default: null }, // left, center, right
+            header: { default: false },
+        },
+        tableRole: "cell",
+    },
+};
+
+const baseMarks = {
+    bold: {},
+    italic: {},
+    link: {
+        attrs: {
+            href: {},
+            title: { default: null },
+        },
+    },
+    button: {
+        attrs: {
+            href: {},
+            title: { default: null },
+            variant: { default: "primary" },
+        },
+    },
+    code: {
+        // For inline code
+        inclusive: true,
+        code: true,
+    },
+};
+
+/**
+ * Get the base schema definition
+ * @returns {Object} Combined schema with nodes and marks
+ */
+function getBaseSchema() {
+    return {
+        nodes: baseNodes,
+        marks: baseMarks,
+    };
+}
+
+export { getBaseSchema };

package/src/utils.js

@@ -0,0 +1,63 @@
+function isValidUniwebMarkdown(text) {
+    // Early return for empty or very short text
+    if (!text || text.length < 8) return false;
+
+    // More comprehensive and accurate patterns
+    const patterns = [
+        // Links and images
+        /\!\[.*?\]\(.*?\)/, // Image syntax ![alt](src)
+        /\[.*?\]\(.*?\)/, // Link syntax [text](href)
+
+        // Headers
+        /^#{1,6}\s+.+$/m, // Atx headers with proper spacing
+        /^.+\n[=]{2,}$/m, // Setext header level 1
+        /^.+\n[-]{2,}$/m, // Setext header level 2
+
+        // Quotes and lists
+        /^\s{0,3}>\s.+/m, // Blockquote with content
+        /^\s{0,3}(\*|-|\+)\s+.+/m, // Unordered list items with content
+        /^\s{0,3}\d+\.\s+.+/m, // Ordered list items with content
+
+        // Code
+        /^\s{0,3}`{3}[\s\S]*?`{3}/m, // Fenced code blocks
+        /^\s{4}.+/m, // Indented code blocks
+        /`[^`\n]+`/, // Inline code
+
+        // Emphasis
+        /(\*\*|__)[^\*\n_]+(\*\*|__)/, // Bold
+        /(\*|_)[^\*\n_]+(\*|_)/, // Italic
+        /(\*\*\*|___)[^\*\n_]+(\*\*\*|___)/, // Bold and italic
+
+        // Other elements
+        /^\s{0,3}([-*_]){3,}\s*$/m, // Horizontal rules
+        /^\s{0,3}\|.+\|.+\|/m, // Tables
+        /^\s{0,3}\|[-:| ]+\|/m, // Table formatting row
+    ];
+
+    // Check if the text contains any markdown patterns
+    const hasMarkdown = patterns.some((pattern) => pattern.test(text));
+
+    return hasMarkdown;
+    // Add heuristics to reduce false positives
+    // if (hasMarkdown) {
+    //     // If it's just a very short text with asterisks or underscores, it might be regular emphasis
+    //     if (text.length < 30 && /^[^*_`#\[\]\(\)\n\|\-]+$/.test(text)) {
+    //         return false;
+    //     }
+
+    //     // Calculate a "markdown density" - if there are multiple patterns it's more likely to be markdown
+    //     let matchCount = 0;
+    //     patterns.forEach((pattern) => {
+    //         const matches = text.match(pattern);
+    //         if (matches) matchCount += matches.length;
+    //     });
+
+    //     // Higher threshold for very short texts to avoid false positives
+    //     const minMatches = text.length < 48 ? 2 : 1;
+    //     return matchCount >= minMatches;
+    // }
+
+    // return false;
+}
+
+export { isValidUniwebMarkdown };

package/tests/code.test.js

@@ -0,0 +1,122 @@
+import { markdownToProseMirror } from "../src/index.js";
+
+describe("Code Parsing", () => {
+  test("parses fenced code blocks and single quotes", () => {
+    const markdown = "```javascript\nconst x = 1;\nconsole.log('x:', x);\n```";
+    const result = markdownToProseMirror(markdown);
+
+    expect(result).toEqual({
+      type: "doc",
+      content: [
+        {
+          type: "codeBlock",
+          attrs: {
+            language: "javascript",
+            filename: null,
+          },
+          content: [
+            {
+              type: "text",
+              text: "const x = 1;\nconsole.log('x:', x);",
+            },
+          ],
+        },
+      ],
+    });
+  });
+
+  test("parses code blocks with filenames", () => {
+    const markdown = "```javascript:example.js\nconst x = 1;\n```";
+    const result = markdownToProseMirror(markdown);
+
+    expect(result).toEqual({
+      type: "doc",
+      content: [
+        {
+          type: "codeBlock",
+          attrs: {
+            language: "javascript",
+            filename: "example.js",
+          },
+          content: [
+            {
+              type: "text",
+              text: "const x = 1;",
+            },
+          ],
+        },
+      ],
+    });
+  });
+
+  test("parses indented code blocks", () => {
+    const markdown = "    const x = 1;\n    console.log(x);";
+    const result = markdownToProseMirror(markdown);
+
+    expect(result).toEqual({
+      type: "doc",
+      content: [
+        {
+          type: "codeBlock",
+          attrs: {
+            language: null,
+            filename: null,
+          },
+          content: [
+            {
+              type: "text",
+              text: "const x = 1;\nconsole.log(x);",
+            },
+          ],
+        },
+      ],
+    });
+  });
+
+  test("parses inline code", () => {
+    const markdown = "Use the `console.log('test')` function.";
+    const result = markdownToProseMirror(markdown);
+
+    expect(result).toEqual({
+      type: "doc",
+      content: [
+        {
+          type: "paragraph",
+          content: [
+            { type: "text", text: "Use the " },
+            {
+              type: "text",
+              text: "console.log('test')",
+              marks: [{ type: "code" }],
+            },
+            { type: "text", text: " function." },
+          ],
+        },
+      ],
+    });
+  });
+
+  test("preserves empty lines in code blocks", () => {
+    const markdown = "```\nline 1\n\nline 2\n```";
+    const result = markdownToProseMirror(markdown);
+
+    expect(result).toEqual({
+      type: "doc",
+      content: [
+        {
+          type: "codeBlock",
+          attrs: {
+            language: null,
+            filename: null,
+          },
+          content: [
+            {
+              type: "text",
+              text: "line 1\n\nline 2",
+            },
+          ],
+        },
+      ],
+    });
+  });
+});