testomatio-editor-blocks 0.4.60 → 0.4.62

package/package/editor/customMarkdownConverter.js

@@ -22,7 +22,7 @@ const headingPrefixes = {
     5: "#####",
     6: "######",
 };
-const SPECIAL_CHAR_REGEX = /([*_`~()<\\])/g;
+const SPECIAL_CHAR_REGEX = /([*_`~()\\])/g;
 const HTML_COMMENT_REGEX = /<!--[\s\S]*?-->/g;
 const HTML_SPAN_REGEX = /<\/?span[^>]*>/g;
 const HTML_UNDERLINE_REGEX = /<\/?u>/g;
@@ -157,6 +157,7 @@ function applyTextStyles(text, styles) {
     return wrapped.join("\n");
 }
 function inlineToMarkdown(content) {
+    var _a;
     if (!content || !Array.isArray(content)) {
         return "";
     }
@@ -174,7 +175,9 @@ function inlineToMarkdown(content) {
                 i += 2;
                 continue;
             }
-            result.push(applyTextStyles(escapeMarkdown(item.text), item.styles));
+            const isCode = ((_a = item.styles) === null || _a === void 0 ? void 0 : _a.code) === true;
+            const rendered = isCode ? item.text : escapeMarkdown(item.text);
+            result.push(applyTextStyles(rendered, item.styles));
             i += 1;
             continue;
         }
@@ -261,7 +264,7 @@ function serializeBlock(block, ctx, orderedIndex, stepIndex) {
         case "codeBlock": {
             const language = block.props.language || "";
             const fence = "```" + language;
-            const body = inlineToMarkdown(block.content);
+            const body = inlineContentToPlainText(block.content);
             lines.push(fence);
             if (body.length > 0) {
                 lines.push(body);
@@ -695,6 +698,11 @@ function parseList(lines, startIndex, listType, indentLevel, allowEmptySteps = f
     var _a, _b, _c, _d;
     const items = [];
     let index = startIndex;
+    // The minimum leading-space count for items at this list level. Initialized to
+    // the parent's expected indent, but updated to the first item's actual indent
+    // so a uniformly indented list stays flat instead of nesting under itself.
+    let baseIndent = indentLevel * 2;
+    let firstItemSeen = false;
     while (index < lines.length) {
         const rawLine = lines[index];
         const trimmed = rawLine.trim();
@@ -712,7 +720,7 @@ function parseList(lines, startIndex, listType, indentLevel, allowEmptySteps = f
             }
             const nextLine = lines[lookahead];
             const nextIndent = countIndent(nextLine);
-            if (nextIndent < indentLevel * 2) {
+            if (nextIndent < baseIndent) {
                 break;
             }
             const nextType = detectListType(nextLine.trim());
@@ -723,13 +731,15 @@ function parseList(lines, startIndex, listType, indentLevel, allowEmptySteps = f
             continue;
         }
         let indent = countIndent(rawLine);
-        if (indent < indentLevel * 2) {
+        if (indent < baseIndent) {
             break;
         }
-        // Check if this line should be parsed as nested content
-        // Only go deeper if indent is at least 2 more than the next level's expected indent
-        const nextLevelExpectedIndent = (indentLevel + 1) * 2;
-        if (indent >= nextLevelExpectedIndent && items.length > 0) {
+        if (!firstItemSeen) {
+            baseIndent = indent;
+            firstItemSeen = true;
+        }
+        // Only go deeper if indent is at least 2 more than this list's base indent
+        if (indent >= baseIndent + 2 && items.length > 0) {
             const lastItem = items.at(-1);
             if (!lastItem) {
                 break;
@@ -877,11 +887,18 @@ function parseTestStep(lines, index, allowEmpty = false, snippetId) {
             rawTrimmed.startsWith("|")) {
             break;
         }
-        // Check for expected result labels with different formatting
-        const expectedMatch = rawTrimmed.match(EXPECTED_LABEL_REGEX);
-        const expectedStarMatch = rawTrimmed.match(/^\*expected\s*\*:\s*(.*)$/i) ||
-            rawTrimmed.match(/^\*expected\*:\s*(.*)$/i) ||
-            rawTrimmed.match(/^\*{1,2}expected\s*:\*{1,2}\s*(.*)$/i);
+        // Check for expected result labels with different formatting.
+        // Strip an optional leading bullet marker so patterns like
+        // "* *Expected*: ..." (a sub-bullet with an italic Expected label) are
+        // recognized via the same matchers as the bare label forms.
+        const bulletPrefixMatch = rawTrimmed.match(/^[*-]\s+/);
+        const lineForExpectedCheck = bulletPrefixMatch
+            ? rawTrimmed.slice(bulletPrefixMatch[0].length)
+            : rawTrimmed;
+        const expectedMatch = lineForExpectedCheck.match(EXPECTED_LABEL_REGEX);
+        const expectedStarMatch = lineForExpectedCheck.match(/^\*expected\s*\*:\s*(.*)$/i) ||
+            lineForExpectedCheck.match(/^\*expected\*:\s*(.*)$/i) ||
+            lineForExpectedCheck.match(/^\*{1,2}expected\s*:\*{1,2}\s*(.*)$/i);
         if (expectedMatch || expectedStarMatch) {
             inExpectedResult = true;
             // Prefer the star match (more specific about formatting) to avoid leaking markers
@@ -890,7 +907,7 @@ function parseTestStep(lines, index, allowEmpty = false, snippetId) {
                 content = (expectedStarMatch[1] || '').trim();
             }
             else {
-                content = rawTrimmed.slice(expectedMatch[0].length).trim();
+                content = lineForExpectedCheck.slice(expectedMatch[0].length).trim();
             }
             // Add the content (if any) from this line
             if (content) {
@@ -1054,7 +1071,23 @@ function parseCodeBlock(lines, index) {
     if (!trimmed.startsWith("```")) {
         return null;
     }
-    const language = trimmed.slice(3).trim();
+    const afterOpening = trimmed.slice(3);
+    const closeMatch = afterOpening.match(/```\s*$/);
+    if (closeMatch) {
+        const content = afterOpening.slice(0, afterOpening.length - closeMatch[0].length);
+        return {
+            block: {
+                type: "codeBlock",
+                props: { language: "" },
+                content: content.length
+                    ? [{ type: "text", text: content, styles: {} }]
+                    : undefined,
+                children: [],
+            },
+            nextIndex: index + 1,
+        };
+    }
+    const language = afterOpening.trim();
     const body = [];
     let next = index + 1;
     while (next < lines.length && !lines[next].startsWith("```")) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testomatio-editor-blocks",
-  "version": "0.4.60",
+  "version": "0.4.62",
   "description": "Custom BlockNote schema, markdown conversion helpers, and UI for Testomatio-style test cases and steps.",
   "type": "module",
   "main": "./package/index.js",

package/src/editor/customMarkdownConverter.test.ts

@@ -62,7 +62,7 @@ describe("blocksToMarkdown", () => {
     expect(blocksToMarkdown(blocks)).toBe("<!-- ai/agent generated description -->");
   });
 
-  it("preserves HTML comments inline among text and still escapes stray angle brackets", () => {
+  it("preserves HTML comments inline among text without escaping stray angle brackets", () => {
     const blocks: CustomEditorBlock[] = [
       {
         id: "c2",
@@ -75,7 +75,98 @@ describe("blocksToMarkdown", () => {
       },
     ];
 
-    expect(blocksToMarkdown(blocks)).toBe("before <!-- note --> after \\<div>");
+    expect(blocksToMarkdown(blocks)).toBe("before <!-- note --> after <div>");
+  });
+
+  it("does not escape `<` in plain text (e.g. comparison operators)", () => {
+    const blocks: CustomEditorBlock[] = [
+      {
+        id: "p_lt",
+        type: "paragraph",
+        props: baseProps,
+        content: [
+          { type: "text", text: "< 768px is mobile", styles: {} },
+        ],
+        children: [],
+      },
+    ];
+
+    expect(blocksToMarkdown(blocks)).toBe("< 768px is mobile");
+  });
+
+  it("does not escape `<` in table cells (viewport breakpoints case)", () => {
+    const markdown = [
+      "| Viewport Width | Layout Expected | Nav Behavior |",
+      "| --- | --- | --- |",
+      "| < 768px | Single column | Hamburger menu |",
+      "| 768px – 1024px | Two column | Collapsed sidebar |",
+      "| > 1024px | Full desktop layout | Full nav visible |",
+    ].join("\n");
+
+    const blocks = markdownToBlocks(markdown);
+    const out = blocksToMarkdown(blocks as CustomEditorBlock[]);
+    expect(out).toBe(markdown);
+    expect(out).not.toContain("\\<");
+  });
+
+  it("does not escape markdown chars inside inline code", () => {
+    const blocks: CustomEditorBlock[] = [
+      {
+        id: "p_code",
+        type: "paragraph",
+        props: baseProps,
+        content: [
+          { type: "text", text: "**bold**", styles: { code: true } },
+        ],
+        children: [],
+      },
+    ];
+
+    expect(blocksToMarkdown(blocks)).toBe("`**bold**`");
+  });
+
+  it("does not escape markdown chars inside inline code in a table (syntax/rendered case)", () => {
+    const markdown = [
+      "| Syntax | Rendered As |",
+      "| --- | --- |",
+      "| `**bold**` | **bold** |",
+      "| `*italic*` | _italic_ |",
+      "| `~~strike~~` | ~~strike~~ |",
+    ].join("\n");
+
+    const blocks = markdownToBlocks(markdown);
+    const out = blocksToMarkdown(blocks as CustomEditorBlock[]);
+    expect(out).toBe(markdown);
+    expect(out).not.toMatch(/\\[*_~]/);
+  });
+
+  it("does not escape markdown chars inside fenced code blocks", () => {
+    const markdown = [
+      "```",
+      "**bold** _italic_ ~~strike~~ <div>",
+      "```",
+    ].join("\n");
+
+    const blocks = markdownToBlocks(markdown);
+    const out = blocksToMarkdown(blocks as CustomEditorBlock[]);
+    expect(out).toBe(markdown);
+    expect(out).not.toMatch(/\\[*_~<]/);
+  });
+
+  it("still escapes literal backticks inside inline code", () => {
+    const blocks: CustomEditorBlock[] = [
+      {
+        id: "p_tick",
+        type: "paragraph",
+        props: baseProps,
+        content: [
+          { type: "text", text: "a`b", styles: { code: true } },
+        ],
+        children: [],
+      },
+    ];
+
+    expect(blocksToMarkdown(blocks)).toBe("`a\\`b`");
   });
 
   it("places bold markers outside leading/trailing spaces", () => {
@@ -758,6 +849,86 @@ describe("markdownToBlocks", () => {
     ]);
   });
 
+  it("parses sub-bulleted *Expected*: lines as the step's expected result", () => {
+    const markdown = [
+      "### Steps",
+      "",
+      "* Navigate to the “Transfer Funds” page.",
+      "  * *Expected*: The Transfer Funds page loads, showing fields for source account, destination account, and amount.",
+      "",
+      "* Select the user’s own source account from the dropdown list.",
+      "  * *Expected*: The selected account is displayed and its current balance is shown.",
+    ].join("\n");
+
+    const blocks = markdownToBlocks(markdown);
+    const stepBlocks = blocks.filter((b) => b.type === "testStep");
+    expect(stepBlocks).toEqual([
+      {
+        type: "testStep",
+        props: {
+          stepTitle: "Navigate to the “Transfer Funds” page.",
+          stepData: "",
+          expectedResult:
+            "The Transfer Funds page loads, showing fields for source account, destination account, and amount.\n",
+          listStyle: "bullet",
+        },
+        children: [],
+      },
+      {
+        type: "testStep",
+        props: {
+          stepTitle: "Select the user’s own source account from the dropdown list.",
+          stepData: "",
+          expectedResult:
+            "The selected account is displayed and its current balance is shown.",
+          listStyle: "bullet",
+        },
+        children: [],
+      },
+    ]);
+  });
+
+  it("parses sub-bulleted **Expected**: (bold) lines as the step's expected result", () => {
+    const markdown = [
+      "### Steps",
+      "",
+      "* Open the Login page.",
+      "  * **Expected**: The Login page loads successfully.",
+    ].join("\n");
+
+    const blocks = markdownToBlocks(markdown);
+    const stepBlocks = blocks.filter((b) => b.type === "testStep");
+    expect(stepBlocks).toEqual([
+      {
+        type: "testStep",
+        props: {
+          stepTitle: "Open the Login page.",
+          stepData: "",
+          expectedResult: "The Login page loads successfully.",
+          listStyle: "bullet",
+        },
+        children: [],
+      },
+    ]);
+  });
+
+  it("round-trips sub-bulleted *Expected*: lines through the canonical serialized form", () => {
+    const markdown = [
+      "### Steps",
+      "",
+      "* Navigate to the “Transfer Funds” page.",
+      "  * *Expected*: The Transfer Funds page loads.",
+    ].join("\n");
+
+    const firstPass = markdownToBlocks(markdown);
+    const serialized = blocksToMarkdown(firstPass as CustomEditorBlock[]);
+    const secondPass = markdownToBlocks(serialized);
+
+    const firstSteps = firstPass.filter((b) => b.type === "testStep");
+    const secondSteps = secondPass.filter((b) => b.type === "testStep");
+    expect(secondSteps).toEqual(firstSteps);
+  });
+
   it("parses a step with empty title but with step data", () => {
     const markdown = ["### Steps", "", "* ", "  Navigate to the page"].join("\n");
 
@@ -1241,6 +1412,25 @@ describe("markdownToBlocks", () => {
     expect(nestedChildren.some((child) => child.type === "bulletListItem")).toBe(true);
   });
 
+  it("parses a uniformly indented list as a flat top-level list", () => {
+    const markdown = [
+      "# Requirements",
+      "",
+      "    * User has an active account on the platform.",
+      "    * User has sufficient funds in the source account.",
+      "    * QR code contains valid transfer details and is scannable.",
+      "    * The device has camera access and QR scanning capability.",
+      "    * The user is authenticated and authorized to perform transfers.",
+    ].join("\n");
+
+    const blocks = markdownToBlocks(markdown);
+    const bulletItems = blocks.filter((b) => b.type === "bulletListItem");
+    expect(bulletItems).toHaveLength(5);
+    for (const item of bulletItems) {
+      expect(item.children ?? []).toEqual([]);
+    }
+  });
+
   it("does not freeze on indented list items without a parent", () => {
     const markdown = [
       "### Requirements",
@@ -2412,6 +2602,59 @@ describe("markdownToBlocks", () => {
     // Most importantly: should not have a standalone "!" at the end
     expect(roundTripMarkdown).not.toMatch(/\n!\s*$/);
   });
+
+  it("parses a single-line fenced code block", () => {
+    const markdown = "```{{baseURL}}/endpoint?query_param_one=value_one&query_param_two=value_two```";
+    const blocks = markdownToBlocks(markdown);
+    expect(blocks).toEqual([
+      {
+        type: "codeBlock",
+        props: { language: "" },
+        content: [
+          {
+            type: "text",
+            text: "{{baseURL}}/endpoint?query_param_one=value_one&query_param_two=value_two",
+            styles: {},
+          },
+        ],
+        children: [],
+      },
+    ]);
+  });
+
+  it("parses an empty single-line fence without swallowing following lines", () => {
+    const markdown = ["``````", "next line"].join("\n");
+    const blocks = markdownToBlocks(markdown);
+    expect(blocks).toHaveLength(2);
+    expect(blocks[0]).toEqual({
+      type: "codeBlock",
+      props: { language: "" },
+      content: undefined,
+      children: [],
+    });
+    expect(blocks[1].type).toBe("paragraph");
+  });
+
+  it("normalizes a single-line fenced code block to multi-line on round-trip", () => {
+    const markdown = "```hello world```";
+    const blocks = markdownToBlocks(markdown);
+    expect(blocksToMarkdown(blocks as CustomEditorBlock[])).toBe(
+      ["```", "hello world", "```"].join("\n"),
+    );
+  });
+
+  it("still treats an opening fence with a language identifier as multi-line", () => {
+    const markdown = ["```js", "const x = 1;", "```"].join("\n");
+    const blocks = markdownToBlocks(markdown);
+    expect(blocks).toEqual([
+      {
+        type: "codeBlock",
+        props: { language: "js" },
+        content: [{ type: "text", text: "const x = 1;", styles: {} }],
+        children: [],
+      },
+    ]);
+  });
 });
 
 describe("file block serialization", () => {

package/src/editor/customMarkdownConverter.ts

@@ -60,7 +60,7 @@ const headingPrefixes: Record<number, string> = {
   6: "######",
 };
 
-const SPECIAL_CHAR_REGEX = /([*_`~()<\\])/g;
+const SPECIAL_CHAR_REGEX = /([*_`~()\\])/g;
 const HTML_COMMENT_REGEX = /<!--[\s\S]*?-->/g;
 const HTML_SPAN_REGEX = /<\/?span[^>]*>/g;
 const HTML_UNDERLINE_REGEX = /<\/?u>/g;
@@ -234,7 +234,9 @@ function inlineToMarkdown(content: CustomEditorBlock["content"]): string {
         i += 2;
         continue;
       }
-      result.push(applyTextStyles(escapeMarkdown(item.text), item.styles));
+      const isCode = (item.styles as any)?.code === true;
+      const rendered = isCode ? item.text : escapeMarkdown(item.text);
+      result.push(applyTextStyles(rendered, item.styles));
       i += 1;
       continue;
     }
@@ -334,7 +336,7 @@ function serializeBlock(
     case "codeBlock": {
       const language = (block.props as any).language || "";
       const fence = "```" + language;
-      const body = inlineToMarkdown(block.content);
+      const body = inlineContentToPlainText(block.content);
       lines.push(fence);
       if (body.length > 0) {
         lines.push(body);
@@ -843,6 +845,11 @@ function parseList(
 ): ListParseResult {
   const items: CustomPartialBlock[] = [];
   let index = startIndex;
+  // The minimum leading-space count for items at this list level. Initialized to
+  // the parent's expected indent, but updated to the first item's actual indent
+  // so a uniformly indented list stays flat instead of nesting under itself.
+  let baseIndent = indentLevel * 2;
+  let firstItemSeen = false;
 
   while (index < lines.length) {
     const rawLine = lines[index];
@@ -862,7 +869,7 @@ function parseList(
       }
       const nextLine = lines[lookahead];
       const nextIndent = countIndent(nextLine);
-      if (nextIndent < indentLevel * 2) {
+      if (nextIndent < baseIndent) {
         break;
       }
       const nextType = detectListType(nextLine.trim());
@@ -875,14 +882,17 @@ function parseList(
 
     let indent = countIndent(rawLine);
 
-    if (indent < indentLevel * 2) {
+    if (indent < baseIndent) {
       break;
     }
 
-    // Check if this line should be parsed as nested content
-    // Only go deeper if indent is at least 2 more than the next level's expected indent
-    const nextLevelExpectedIndent = (indentLevel + 1) * 2;
-    if (indent >= nextLevelExpectedIndent && items.length > 0) {
+    if (!firstItemSeen) {
+      baseIndent = indent;
+      firstItemSeen = true;
+    }
+
+    // Only go deeper if indent is at least 2 more than this list's base indent
+    if (indent >= baseIndent + 2 && items.length > 0) {
       const lastItem = items.at(-1);
       if (!lastItem) {
         break;
@@ -1061,11 +1071,18 @@ function parseTestStep(
       break;
     }
 
-    // Check for expected result labels with different formatting
-    const expectedMatch = rawTrimmed.match(EXPECTED_LABEL_REGEX);
-    const expectedStarMatch = rawTrimmed.match(/^\*expected\s*\*:\s*(.*)$/i) ||
-                               rawTrimmed.match(/^\*expected\*:\s*(.*)$/i) ||
-                               rawTrimmed.match(/^\*{1,2}expected\s*:\*{1,2}\s*(.*)$/i);
+    // Check for expected result labels with different formatting.
+    // Strip an optional leading bullet marker so patterns like
+    // "* *Expected*: ..." (a sub-bullet with an italic Expected label) are
+    // recognized via the same matchers as the bare label forms.
+    const bulletPrefixMatch = rawTrimmed.match(/^[*-]\s+/);
+    const lineForExpectedCheck = bulletPrefixMatch
+      ? rawTrimmed.slice(bulletPrefixMatch[0].length)
+      : rawTrimmed;
+    const expectedMatch = lineForExpectedCheck.match(EXPECTED_LABEL_REGEX);
+    const expectedStarMatch = lineForExpectedCheck.match(/^\*expected\s*\*:\s*(.*)$/i) ||
+                               lineForExpectedCheck.match(/^\*expected\*:\s*(.*)$/i) ||
+                               lineForExpectedCheck.match(/^\*{1,2}expected\s*:\*{1,2}\s*(.*)$/i);
 
     if (expectedMatch || expectedStarMatch) {
       inExpectedResult = true;
@@ -1074,7 +1091,7 @@ function parseTestStep(
       if (expectedStarMatch) {
         content = (expectedStarMatch[1] || '').trim();
       } else {
-        content = rawTrimmed.slice(expectedMatch![0].length).trim();
+        content = lineForExpectedCheck.slice(expectedMatch![0].length).trim();
       }
 
       // Add the content (if any) from this line
@@ -1256,7 +1273,24 @@ function parseCodeBlock(lines: string[], index: number): { block: CustomPartialB
     return null;
   }
 
-  const language = trimmed.slice(3).trim();
+  const afterOpening = trimmed.slice(3);
+  const closeMatch = afterOpening.match(/```\s*$/);
+  if (closeMatch) {
+    const content = afterOpening.slice(0, afterOpening.length - closeMatch[0].length);
+    return {
+      block: {
+        type: "codeBlock",
+        props: { language: "" },
+        content: content.length
+          ? [{ type: "text", text: content, styles: {} }]
+          : undefined,
+        children: [],
+      },
+      nextIndex: index + 1,
+    };
+  }
+
+  const language = afterOpening.trim();
   const body: string[] = [];
   let next = index + 1;
   while (next < lines.length && !lines[next].startsWith("```") ) {