testomatio-editor-blocks 0.4.19 → 0.4.20

package/package/editor/customMarkdownConverter.js

@@ -237,7 +237,7 @@ function serializeBlock(block, ctx, orderedIndex, stepIndex) {
         }
         case "bulletListItem": {
             const text = inlineToMarkdown(block.content);
-            lines.push(`${indent}- ${text}`.trimEnd());
+            lines.push(`${indent}* ${text}`.trimEnd());
             lines.push(...serializeChildren(block, ctx));
             return lines;
         }
@@ -624,13 +624,11 @@ function parseList(lines, startIndex, listType, indentLevel, allowEmptySteps = f
             break;
         }
         // Only try to parse as testStep for top-level items (indentLevel === 0)
-        // when we're under a Steps heading AND the list type is bullet
-        // Numbered lists under Steps heading are only parsed as test steps if they look like test steps
-        if (indentLevel === 0 && (allowEmptySteps || listType === "bullet")) {
-            // For bullet lists, always try to parse as test steps
-            // For numbered lists, only try if they have step-like characteristics
+        // Under a Steps heading (allowEmptySteps=true): always try for both bullet and numbered
+        // Outside Steps heading: only if the item looks like a test step (has Expected markers or indented data)
+        if (indentLevel === 0 && (allowEmptySteps || isLikelyStep(lines, index))) {
             const looksLikeTestStep = listType === "bullet" ||
-                (listType === "numbered" && (isLikelyStep(lines, index)));
+                (listType === "numbered" && (allowEmptySteps || isLikelyStep(lines, index)));
             if (looksLikeTestStep) {
                 const nextStep = parseTestStep(lines, index, allowEmptySteps);
                 if (nextStep) {
@@ -678,20 +676,28 @@ function parseList(lines, startIndex, listType, indentLevel, allowEmptySteps = f
 }
 function isLikelyStep(lines, index) {
     // Look ahead to see if there's indented content or expected result
-    if (index + 1 >= lines.length)
-        return false;
-    const nextLine = lines[index + 1];
-    const hasIndent = /^\s{2,}/.test(nextLine);
-    // Check if the next line contains expected result markers
-    const nextTrimmed = nextLine.trim();
-    const hasExpectedResult = EXPECTED_LABEL_REGEX.test(nextTrimmed);
-    // Only consider it a test step if:
-    // 1. It has an expected result, OR
-    // 2. The next line is indented but doesn't start with a numbered or bullet list
-    if (hasExpectedResult)
-        return true;
-    if (hasIndent && !/^\d+[.)]/.test(nextTrimmed) && !/^[-*+]/.test(nextTrimmed))
-        return true;
+    // Look ahead through subsequent lines for expected result markers or indented content
+    for (let i = index + 1; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        // Stop at blank lines
+        if (!trimmed)
+            break;
+        // Check for indented content (step data) first — indented lines indicate a test step
+        const hasIndent = /^\s{2,}/.test(line);
+        if (hasIndent)
+            return true;
+        // Stop at new list items, headings, or other block-level elements (only if not indented)
+        if (/^[-*+]\s/.test(trimmed) || /^\d+[.)]\s/.test(trimmed))
+            break;
+        if (trimmed.startsWith("#") || trimmed.startsWith(">") || trimmed.startsWith("|") || trimmed.startsWith("```") || trimmed.startsWith(":::"))
+            break;
+        // Check for expected result markers
+        if (EXPECTED_LABEL_REGEX.test(trimmed))
+            return true;
+        if (trimmed.match(/^\*[^*]*expected/i))
+            return true;
+    }
     return false;
 }
 function parseTestStep(lines, index, allowEmpty = false, snippetId) {
@@ -1145,7 +1151,9 @@ export function markdownToBlocks(markdown) {
             index = snippetWrapper.nextIndex;
             continue;
         }
-        const stepLikeBlock = parseTestStep(lines, index, stepsHeadingLevel !== null);
+        const stepLikeBlock = (stepsHeadingLevel !== null || isLikelyStep(lines, index))
+            ? parseTestStep(lines, index, stepsHeadingLevel !== null)
+            : null;
         if (stepLikeBlock) {
             blocks.push(stepLikeBlock.block);
             index = stepLikeBlock.nextIndex;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testomatio-editor-blocks",
-  "version": "0.4.19",
+  "version": "0.4.20",
   "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

@@ -485,37 +485,9 @@ describe("markdownToBlocks", () => {
     const blocks = markdownToBlocks(markdown);
     const stepBlocks = blocks.filter((block) => block.type === "testStep");
 
+    // Preconditions and Postconditions bullets are now parsed as bulletListItem (not testStep)
+    // Only items under the "Steps" heading with Expected markers remain as testSteps
     expect(stepBlocks).toEqual([
-      {
-        type: "testStep",
-        props: {
-          stepTitle: "The user is logged into the application.",
-          stepData: "",
-          expectedResult: "",
-          listStyle: "bullet",
-        },
-        children: [],
-      },
-      {
-        type: "testStep",
-        props: {
-          stepTitle: "The user has the necessary permissions to receive notifications.",
-          stepData: "",
-          expectedResult: "",
-          listStyle: "bullet",
-        },
-        children: [],
-      },
-      {
-        type: "testStep",
-        props: {
-          stepTitle: "The application is configured to send real-time notifications.",
-          stepData: "",
-          expectedResult: "",
-          listStyle: "bullet",
-        },
-        children: [],
-      },
       {
         type: "testStep",
         props: {
@@ -556,26 +528,6 @@ describe("markdownToBlocks", () => {
         },
         children: [],
       },
-      {
-        type: "testStep",
-        props: {
-          stepTitle: "The user has received and viewed the notifications.",
-          stepData: "",
-          expectedResult: "",
-          listStyle: "bullet",
-        },
-        children: [],
-      },
-      {
-        type: "testStep",
-        props: {
-          stepTitle: "The application continues to function as expected after receiving and processing the notifications.",
-          stepData: "",
-          expectedResult: "",
-          listStyle: "bullet",
-        },
-        children: [],
-      },
     ]);
   });
 
@@ -674,33 +626,21 @@ describe("markdownToBlocks", () => {
         children: [],
       },
       {
-        type: "testStep",
-        props: {
-          stepTitle: "The user is logged into the application.",
-          stepData: "",
-          expectedResult: "",
-          listStyle: "bullet",
-        },
+        type: "bulletListItem",
+        props: baseProps,
+        content: [{ type: "text", text: "The user is logged into the application.", styles: {} }],
         children: [],
       },
       {
-        type: "testStep",
-        props: {
-          stepTitle: "The user has the necessary permissions to receive notifications.",
-          stepData: "",
-          expectedResult: "",
-          listStyle: "bullet",
-        },
+        type: "bulletListItem",
+        props: baseProps,
+        content: [{ type: "text", text: "The user has the necessary permissions to receive notifications.", styles: {} }],
         children: [],
       },
       {
-        type: "testStep",
-        props: {
-          stepTitle: "The application is configured to send real-time notifications.",
-          stepData: "",
-          expectedResult: "",
-          listStyle: "bullet",
-        },
+        type: "bulletListItem",
+        props: baseProps,
+        content: [{ type: "text", text: "The application is configured to send real-time notifications.", styles: {} }],
         children: [],
       },
     ]);
@@ -1008,13 +948,9 @@ describe("markdownToBlocks", () => {
         children: [],
       },
       {
-        type: "testStep",
-        props: {
-          stepTitle: "Bullet",
-          stepData: "",
-          expectedResult: "",
-          listStyle: "bullet",
-        },
+        type: "bulletListItem",
+        props: baseProps,
+        content: [{ type: "text", text: "Bullet", styles: {} }],
         children: [],
       },
     ]);

package/src/editor/customMarkdownConverter.ts

@@ -314,7 +314,7 @@ function serializeBlock(
     }
     case "bulletListItem": {
       const text = inlineToMarkdown(block.content);
-      lines.push(`${indent}- ${text}`.trimEnd());
+      lines.push(`${indent}* ${text}`.trimEnd());
       lines.push(...serializeChildren(block, ctx));
       return lines;
     }
@@ -777,14 +777,12 @@ function parseList(
     }
 
     // Only try to parse as testStep for top-level items (indentLevel === 0)
-    // when we're under a Steps heading AND the list type is bullet
-    // Numbered lists under Steps heading are only parsed as test steps if they look like test steps
-    if (indentLevel === 0 && (allowEmptySteps || listType === "bullet")) {
-      // For bullet lists, always try to parse as test steps
-      // For numbered lists, only try if they have step-like characteristics
+    // Under a Steps heading (allowEmptySteps=true): always try for both bullet and numbered
+    // Outside Steps heading: only if the item looks like a test step (has Expected markers or indented data)
+    if (indentLevel === 0 && (allowEmptySteps || isLikelyStep(lines, index))) {
       const looksLikeTestStep = listType === "bullet" ||
         (listType === "numbered" && (
-          isLikelyStep(lines, index)
+          allowEmptySteps || isLikelyStep(lines, index)
         ));
 
       if (looksLikeTestStep) {
@@ -836,20 +834,26 @@ function parseList(
 
 function isLikelyStep(lines: string[], index: number): boolean {
   // Look ahead to see if there's indented content or expected result
-  if (index + 1 >= lines.length) return false;
+  // Look ahead through subsequent lines for expected result markers or indented content
+  for (let i = index + 1; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    // Stop at blank lines
+    if (!trimmed) break;
 
-  const nextLine = lines[index + 1];
-  const hasIndent = /^\s{2,}/.test(nextLine);
+    // Check for indented content (step data) first — indented lines indicate a test step
+    const hasIndent = /^\s{2,}/.test(line);
+    if (hasIndent) return true;
 
-  // Check if the next line contains expected result markers
-  const nextTrimmed = nextLine.trim();
-  const hasExpectedResult = EXPECTED_LABEL_REGEX.test(nextTrimmed);
+    // Stop at new list items, headings, or other block-level elements (only if not indented)
+    if (/^[-*+]\s/.test(trimmed) || /^\d+[.)]\s/.test(trimmed)) break;
+    if (trimmed.startsWith("#") || trimmed.startsWith(">") || trimmed.startsWith("|") || trimmed.startsWith("```") || trimmed.startsWith(":::")) break;
 
-  // Only consider it a test step if:
-  // 1. It has an expected result, OR
-  // 2. The next line is indented but doesn't start with a numbered or bullet list
-  if (hasExpectedResult) return true;
-  if (hasIndent && !/^\d+[.)]/.test(nextTrimmed) && !/^[-*+]/.test(nextTrimmed)) return true;
+    // Check for expected result markers
+    if (EXPECTED_LABEL_REGEX.test(trimmed)) return true;
+    if (trimmed.match(/^\*[^*]*expected/i)) return true;
+  }
 
   return false;
 }
@@ -1377,7 +1381,9 @@ export function markdownToBlocks(markdown: string): CustomPartialBlock[] {
       continue;
     }
 
-    const stepLikeBlock = parseTestStep(lines, index, stepsHeadingLevel !== null);
+    const stepLikeBlock = (stepsHeadingLevel !== null || isLikelyStep(lines, index))
+      ? parseTestStep(lines, index, stepsHeadingLevel !== null)
+      : null;
     if (stepLikeBlock) {
       blocks.push(stepLikeBlock.block);
       index = stepLikeBlock.nextIndex;