testomatio-editor-blocks 0.4.19 → 0.4.21

package/package/editor/blocks/step.d.ts

@@ -1,3 +1,4 @@
+export declare const isEmptyParagraph: (b: any) => boolean;
 export declare const stepBlock: {
     config: {
         readonly type: "testStep";

package/package/editor/blocks/step.js

@@ -43,6 +43,10 @@ const writeStepViewMode = (mode) => {
         //
     }
 };
+export const isEmptyParagraph = (b) => b.type === "paragraph" &&
+    (!Array.isArray(b.content) ||
+        b.content.length === 0 ||
+        b.content.every((n) => { var _a; return n.type === "text" && !((_a = n.text) === null || _a === void 0 ? void 0 : _a.trim()); }));
 export const stepBlock = createReactBlockSpec({
     type: "testStep",
     content: "none",
@@ -82,9 +86,13 @@ export const stepBlock = createReactBlockSpec({
                 return 1;
             let count = 1;
             for (let i = blockIndex - 1; i >= 0; i--) {
-                if (allBlocks[i].type === "testStep") {
+                const b = allBlocks[i];
+                if (b.type === "testStep") {
                     count++;
                 }
+                else if (isEmptyParagraph(b)) {
+                    continue;
+                }
                 else {
                     break;
                 }
@@ -99,7 +107,7 @@ export const stepBlock = createReactBlockSpec({
                 return false;
             for (let i = blockIndex - 1; i >= 0; i--) {
                 const b = allBlocks[i];
-                if (b.type === "testStep" || b.type === "snippet") {
+                if (b.type === "testStep" || b.type === "snippet" || isEmptyParagraph(b)) {
                     continue;
                 }
                 if (b.type === "heading") {

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.21",
   "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/blocks/blocks.test.ts

@@ -1,5 +1,41 @@
 import { describe, expect, it } from "vitest";
 import { customSchema } from "../customSchema";
+import { isEmptyParagraph } from "./step";
+
+describe("isEmptyParagraph", () => {
+  it("returns true for paragraph with no content", () => {
+    expect(isEmptyParagraph({ type: "paragraph", content: [], children: [] })).toBe(true);
+  });
+
+  it("returns true for paragraph with undefined content", () => {
+    expect(isEmptyParagraph({ type: "paragraph", children: [] })).toBe(true);
+  });
+
+  it("returns true for paragraph with only whitespace text", () => {
+    expect(
+      isEmptyParagraph({
+        type: "paragraph",
+        content: [{ type: "text", text: "   " }],
+        children: [],
+      }),
+    ).toBe(true);
+  });
+
+  it("returns false for paragraph with text content", () => {
+    expect(
+      isEmptyParagraph({
+        type: "paragraph",
+        content: [{ type: "text", text: "hello" }],
+        children: [],
+      }),
+    ).toBe(false);
+  });
+
+  it("returns false for non-paragraph blocks", () => {
+    expect(isEmptyParagraph({ type: "heading", content: [], children: [] })).toBe(false);
+    expect(isEmptyParagraph({ type: "testStep", content: [], children: [] })).toBe(false);
+  });
+});
 
 describe("custom block specs", () => {
   it("registers the step block", () => {

package/src/editor/blocks/step.tsx

@@ -47,6 +47,12 @@ const writeStepViewMode = (mode: StepViewMode) => {
   }
 };
 
+export const isEmptyParagraph = (b: any): boolean =>
+  b.type === "paragraph" &&
+  (!Array.isArray(b.content) ||
+    b.content.length === 0 ||
+    b.content.every((n: any) => n.type === "text" && !n.text?.trim()));
+
 export const stepBlock = createReactBlockSpec(
   {
     type: "testStep",
@@ -91,8 +97,11 @@ export const stepBlock = createReactBlockSpec(
 
         let count = 1;
         for (let i = blockIndex - 1; i >= 0; i--) {
-          if (allBlocks[i].type === "testStep") {
+          const b = allBlocks[i];
+          if (b.type === "testStep") {
             count++;
+          } else if (isEmptyParagraph(b)) {
+            continue;
           } else {
             break;
           }
@@ -108,7 +117,7 @@ export const stepBlock = createReactBlockSpec(
 
         for (let i = blockIndex - 1; i >= 0; i--) {
           const b = allBlocks[i];
-          if (b.type === "testStep" || b.type === "snippet") {
+          if (b.type === "testStep" || b.type === "snippet" || isEmptyParagraph(b)) {
             continue;
           }
           if (b.type === "heading") {

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: [],
       },
     ]);
@@ -980,6 +920,46 @@ describe("markdownToBlocks", () => {
     );
   });
 
+  it("parses multiple steps separated by blank lines", () => {
+    const markdown = [
+      "## Steps",
+      "* asjkldnkasndkj",
+      "  *Expected*: slkednfkjsdnfkjsdnf",
+      "",
+      "* sdfnsikdfnsikdn",
+      "  *Expected*: sedfnskdijfns",
+      "",
+      "* sdfnksdjfnsdknf",
+      "  *Expected*: sdjfnskdjfnskdfn",
+    ].join("\n");
+
+    const blocks = markdownToBlocks(markdown);
+    const stepBlocks = blocks.filter((block) => block.type === "testStep");
+
+    expect(stepBlocks).toHaveLength(3);
+
+    expect(stepBlocks[0].props).toEqual({
+      stepTitle: "asjkldnkasndkj",
+      stepData: "",
+      expectedResult: "slkednfkjsdnfkjsdnf\n",
+      listStyle: "bullet",
+    });
+
+    expect(stepBlocks[1].props).toEqual({
+      stepTitle: "sdfnsikdfnsikdn",
+      stepData: "",
+      expectedResult: "sedfnskdijfns\n",
+      listStyle: "bullet",
+    });
+
+    expect(stepBlocks[2].props).toEqual({
+      stepTitle: "sdfnksdjfnsdknf",
+      stepData: "",
+      expectedResult: "sdjfnskdjfnskdfn",
+      listStyle: "bullet",
+    });
+  });
+
   it("round-trips simple blocks", () => {
     const blocks: CustomEditorBlock[] = [
       {
@@ -1008,13 +988,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;